• title: Java学习之路2019.07.28-《周记》 文章目录title: Java学习之路2019.07.28-《周记》一、整体知识点1.static关键字、继承2.封装以及抽象类3.内部类(了解)4.常用类库5.常用类库(Date Calender ...

    title: Java学习之路2019.07.28-《周记》

    一、整体知识点


    1.static关键字、继承

    • static关键字的使用:

      • 可以修饰属性、方法以及引导静态代码块
      • 类成员和实例成员的区别:
        • 类成员:static修饰的实例成员叫做类成员
        • 实例成员:普通属性和方法
        • 类成员为所有对象共享
        • 实例成员为每个对象私有
        • 实例成员必须通过【对象.】的形式访问
        • 类成员可以直接使用【类名.】的形式访问
        • 类方法不能直接使用实例成员,可以直接使用类成员。
        • 实例方法可以直接访问实例成员和类成员
        • 在static修饰的方法和代码块中,不能使用this关键字
        • 可以定义多个静态代码块,按照在源码中的先后顺序完成加载
    • 继承:

      • 一个类继承另外一个类,被继承的类叫做父类(超类、基类),当前类叫做子类

      • 子类继承父类,可以得到父类非私有的属性和方法。 + 不能继承构造方法

      • 子类的构造方法会默认调用父类的无参构造方法

      • 子类继承了父类的方法,发现父类方法不能满足子类需求,那么子类可以对该方法进行重写

      • 重写的要求:
        1、发生在继承关系中
        2、方法结构(返回值类型、方法名、参数列表)必须和继承的方法完全一致
        3、使用的访问修饰符不能严于父类
        public < protected <缺省<private

      • 继承的特点:
        1.传递性
        2.单根性

      • java中所有的类,都间接或者直接继承自Object类。

      • 继承的语法

        [修饰符] class 子类名 extends 父类名{
        }
        
      • 继承的作用:

        • 提高代码的重用性
        • 提高代码的安全性
    • super的使用:

      • super:在子类中表示父类的一个实例
      • 在子类中使用super.属性名的形式访问父类被隐藏的属性
      • 在子类中使用super.方法名的形式访问父类被隐藏的方法
      • 在子类构造方法中使用super([参数列表])的形式来调用父类的构造方法

    2.封装以及抽象类

    • 封装:

      • 把客观事务描述为类的过程就是封装
        一般指的是把类的属性或者方法私有化

      • 属性私有化之后,需要给私有化的属性提供公开的get和set方法

    • final关键字的使用:

      • final:最终的,可以修饰类和方法、属性
      • 用在属性上,这个属性只能被使用,不能被修改,变为常量。
      • 使用final修饰的变量必须初始化赋值。
      • 用在方法上,这个方法不能被重写,变为终极方法
      • 用在类上,这个类不能被继承,变为终极类
    • 抽象类:

      • 定义:当我们在定义类的时候,发现了类中方法不能确定具体实现,那么我们可以把这个方法定义成抽象方法,这个类称为抽象类。
      • 语法格式:
        [修饰符] abstract 返回值类型 方法名([参数列表]);
      • 抽象方法没有方法体({}都没有)。
        类中定义了抽象方法,那么这个类必须声明为抽象类。
      • 子类继承了抽象类,必须对抽象方法进行实现。
      • 抽象方法起到约定的作用。
      • 抽象类不能直接实例化对象,但是可以声明类型。要想实例化对象找对应的子类。
      • 抽象类中可以定义普通方法和属性。
      • 抽象类中不一定有抽象方法,声明了抽象方法的类一定是抽象类。
      • 向上转型:
        子类对象引用赋值给父类的变量。安全。但是会丢失子类特有的属性和行为。
        格式:父类类型 父类引用;
            父类引用=new 子类类型();
        
      • 向下转型:
        父类对象引用赋值给子类的变量。不安全。
        格式:子类类型 子类引用;
              子类引用=(子类类型)父类引用;
        
      • 一定是有关联的对象才能向下转型。多使用instanceof。语法 :对象 instanceof 类类型;
      • 如果没有继承关系的向上或者向下转型,一定是不安全的。
    • 接口

      • 比抽象类还抽象的存在

      • 在接口中只能定义常量和抽象方法

      • 接口的作用:
        1、解决java中类之间单继承的问题 2、达到约定的目的(降低耦合)

      • 接口:interface 接口之间的继承是多继承

      语法格式:

      [修饰符]  class 类名 implements接口1名,接口2名.....{
      	类体;
      	}
      
      • 类实现接口,实现接口中的抽象方法。实现是特殊的继承。
      • 接口不能直接实例化对象,可以定义类型。要想实例化对象找实现类。
    • 接口和抽象类的区别:

      • 接口和抽象类之间的相同点和不同点:
        • 1、不能直接实例化对象
        • 2、一个是interface,一个是class
        • 3、接口中只能定义常量,抽象类中既可以定义常量,也可以定义变量
        • 4、抽象类的继承关系是单继承,接口之间是多继承,类对接口可以多实现
    • 多态

      • 一个事物的多种形态
      • 继承
      • 重写
      • 父类引用指向子类对象
    • 接口的功能:
      多个产品都存在一个相同的功能;这个功能可以被定为一个接口。
      这个接口为这些商产品定义一个统一的规范约束起来。
      此时所有产品实现这个接口。
      然后用一个类进行对接口的具体实现,称为实现类;
      将其属性定义为
      接口类型 接口名
      然后进行方法的具体实现
      接口名.接口中方法()
      最后在测试类中直接调用类中的具体实现方法。

      enter description here

    多态的实现:
    一个事物的两种状态;
    一个事物拥有多种状态时,将多种状态定义为多个接口,
    然后声明这个事物的类,该类同时属于多个接口的实现。重写多个接口中的抽象方法。
    最后在测试时,实例化该类一个对象,并声明多个接口;
    利用 接口名=对象名 向上转型实现对同一对象的不同抽象方法调用。

    enter description here


    3.内部类(了解)

    • 内部类:

      • 定义:当我们定义一个类A的时候,发现类中包含另一个事物B,那么我们可以把事物B定义为内部类。
        类A可以叫做外部类,类B叫做内部类

      1、成员内部类,内部类的位置和外部类的实例成员同一级别
      内部类可以直接访问外部类的属性和方法
      外部类不能直接访问内部类的属性和方法,要想访问可以实例化内部类对象
      在其他类中访问语法: 内部类类型 对象名 = new 外部类类型().new 内部类类型();

      2、方法内部类,定义在方法中
      只能在定义了这个内部类的方法中使用
      方法内部类不能使用访问修饰符,测试类直接调用方法

      3、静态嵌套类,使用static修饰的成员内部类
      内部类可以直接访问外部类的类成员,不能直接实例成员,要想访问实例成员,必须实例外部类的对象
      在其他类中访问语法: 内部类类型 对象名 = new 外部类类型.内部类类型();
      4、匿名内部类
      继承式
      接口式
      参数式

    • 常用类库

      • java的版本:
        javaSE(标准版)、javaEE(企业版)、javaME(移动版开发)
      • 在当前类中使用其他包下的类,这时我们需要把其他包下的类导入到当前类中
      • 在包名之下,类名之上,使用import关键字
      • 语法: import 包名.类名;或者 import 包名.*;
      • java.lang包,java提供的lang包是比较常用的类,使用lang包下的类,不需要导入

    4.常用类库

    • 字符串:String类,不可变字符串,字符串常量

      • 构造方法
      • 常用方法
    • StringBuffer\StringBuilder,可变字符串
      StringBuffer线程安全,常用于全局变量
      StringBuilder线程不安全,用于局部变量,速度比StringBuffer快

    • Math类:数学类

    • 八种基本数据类型对应的包装类

      • 基本数据类型 — 包装类 — 字符串

      • jdk1.5之后基本数据类型和包装类对象可以自动拆封箱

      • 拆箱:对象—基本数据类型

      • 封箱:基本数据类型–对象

      • byte—Byte
        short–Short
        int-----Integer
        long—Long
        float—Float
        double-Double
        char—Character
        boolean-Boolean

    • java.util包
      Date 日期类
      Calendar 日历类
      Scanner 扫描器
      Random 随机数类
      Arrays 数组工具类

    • java.text包
      DateFormat SimpleDateFormat
      NumberFormat DecimalFormat


    5.常用类库(Date Calender SimpleDateFormat)

    • Date
          Date date=new Date();
          System.out.println(date.after(date2));//判断date是不是再date2之后
      	System.out.println(date.before(date2));//判断date是不是再date2之前
      	System.out.println(date.equals(date3));//当getTime得到的毫秒数相同时,结果为true
      
    • Calender
          Calendar now = Calendar.getInstance();
          System.out.println(now);
      	//获取年份
      	System.out.println(now.get(Calendar.YEAR));
      	//获取小时
      	System.out.println(now.get(Calendar.HOUR));//12小时制
      	System.out.println(now.get(Calendar.HOUR_OF_DAY));//24小时制
      	now.add(Calendar.YEAR, -5);//给指定的字段增减值
      	now.set(Calendar.YEAR, 5);
      
    • SimpleDateFormat
          SimpleDateFormat sdf=new SimpleDateFormat();
          //定义一个格式
      	String pattern="yyyy年MM月dd日 HH:mm:ss";
      	
      	//把模式设置给工具
      	sdf.applyPattern(pattern);
      	
      	//实例化一个当前的日期对象
      	Date date=new Date();
      	
      	//把日期对象格式化成日期字符串
      	String str_date=sdf.format(date);
      	System.out.println(str_date);
      	
      	/*
      	 * 日起到字符串:格式化
      	 * 字符串到日期:解析
      	 */
      	String sdate="2019.2.3 12:12:12";	 	//字符串日期
      	//在指定模式的时候,必须定义的模式和字符串日期一致
      	SimpleDateFormat sdf2=new SimpleDateFormat("yyyy.MM.dd HH:mm:ss");
      
      	//解析日期字符串
      	Date date2=sdf2.parse(sdate);
      	System.out.println(sdf2.format(date2));
      

    6.集合框架

    • 集合(很重要)

      • 用来存储批量数据的集合
      • 集合框架包含了集合接口以及对应的实现类

      1.collection,集合框架的跟接口,定义了集合中的通用方法

      • List接口
        1、有序
        2、允许null值
        3、允许重复
        • 实现类ArrayList,线程不安全,基于动态数组实现。查询速速快,删除/新增速度慢
        • 实现类LinkedList,链表实现,线程不安全。删除/新增效率高,查询效率低
        • Vector,线程安全的,效率低
      • Set接口
        1、不允许重复
        2、允许一个null值
        • 实现类HashSet,无序,基于哈希表实现。线程不安全
        • 实现类TreeSet,有序,红黑树实现,线程不安全

      2.Map接口

      • 以键值对的方式来存储,键不允许重复,值允许重复

        • HashMap实现类,基于哈希表,允许null键和null值,线程不安全
        • hashTable实现类,基于哈希表,不允许null键和null值,线程安全
        • Treemap实现类,基于红黑树,允许使用null值,不允许null键,不安全

      在选择集合的时候,如果不是同步的,可以使用Collections工具类中的同步方法完成外部同步。
      格式:Collections.synchronized集合(集合);

    • 思维导图:

    Collection
    enter description here
    Map
    enter description here


    二、经典代码


    1.类的继承

    定义一个类员工类Employee,包含属性薪资和生日月份,以及获取薪资的方法,如果当月员工过生日,会有100元的生日奖励。
    1-1、定义一个销售员工类,是员工类的子类,包含属性销售金额以及提成率。
    1-2、定义一个销售经理类,是销售员工类的子类,包含属性基本薪资
    1-3、定义一个固定薪资的员工类,是员工类的子类,包含属性固定薪资
    1-4、定义一个小时工类,是员工类的子类,包含属性时薪和工作的小时数。超过160个小时的部分按照1.5倍薪资计算。
    定义所有类,使用构造方法完成对象的创建。
    Employee 类:

    code
    

    1-3 Fixation 类:

    package com.zhiyou.day01work;
    
    public class Fixation extends Employee{
    
    	//父类有:属性:salary birthday_month
    	//				 方法:getSalary (int month)
    	int salary;
    	public Fixation(){//空构造函数
    		
    	}
    	//需要获取的值包括 :birthday_month、salary;两者均可以从父类中找到
    	public Fixation( int birthday_month, int salary) {
    		super(birthday_month,salary);
    		
    	}
    	//获取工资方法与父类方法相同
    	
    }
    
    
    

    1-4 HourEmployee 类:

    package com.zhiyou.day01work;
    
    public class HourEmployee extends Employee {
    
    	//父类有:属性:salary birthday_month
    	//				 方法:getSalary (int month)
    	double hourSalary;		//时薪
    	int hour;						//工作时间
    	
    	public HourEmployee() {
    		
    	}
    	//还需获取的有:birthday_month、hourSalary、hour ;其中需要新获得有hourSalary,hour
    	public HourEmployee(int birthday_month,double hourSalary, int hour) {
    		super(birthday_month);			//父类获取生日月
    		this.hourSalary = hourSalary;
    		this.hour = hour;
    	}
    
    	
    	@Override
    	double getSalary(int month) {
    		if(hour>160){
    			return 160*hourSalary+(hour-160)*hourSalary*1.5+super.getSalary(month);
    		}
    		return hour*hourSalary+super.getSalary(month);
    	}
    	
    	
    }
    
    
    

    1-1 SellEmployee 类:

    package com.zhiyou.day01work;
    
    public class SellEmployee extends Employee {
    
    	//父类有:属性:salary birthday_month
    	//				 方法:getSalary (int month)
    	double salesAmount;   //销售金额
    	double royaltyRate; //提成率
    	
    	public SellEmployee() {		//空构造方法
    		
    	}
    	
    	//需要获取的三个值:生日月;销售金额;提成率;其中需要新获得的为 salesAmount、royaltyRate
    	public SellEmployee(int birthday_month,double salesAmount, double royaltyRate) {
    		super(birthday_month);						//生日月已定义,从父类获得
    		this.salesAmount = salesAmount;		
    		this.royaltyRate = royaltyRate;
    	}
    
    	@Override			//获取工资方法不同需要重写方法
    	double getSalary(int month) {
    		return super.getSalary(month)+salesAmount*royaltyRate;
    	}
    	
    }
    
    
    

    1-2 SalesManager 类:

    package com.zhiyou.day01work;
    
    public class SalesManager extends SellEmployee{
    	//父类有:属性:salary、 birthday_month 、salesAmount、 royaltyRate
    	//				 方法:getSalary (int month)
    	
    	double salary; //基本工资
    	
    	public SalesManager() {
    		
    	}
    	
    	//需要获取的有: salary、birthday_month 、salesAmount 、royaltyRate 其中 salary需要新获取
    	public SalesManager( int birthday_month,double salary,double salesAmount,double royaltyRate) {
    		super(birthday_month,salesAmount,royaltyRate);
    		this.salary = salary;
    	}
    
    	double getSalary(int month){
    		return salary+super.getSalary(month);
    	}
    }
    

    测试类:

    package com.zhiyou.day01work;
    
    public class Test {
    
    	public static void main(String[] args) {
    		//销售员工对象创建
    		SellEmployee sellEmployee =new SellEmployee(4,100000,0.2);
    		System.out.println(sellEmployee.getSalary(5));
    		
    		//固定工资员工对象创建
    		Fixation fixation=new Fixation(5,4000);
    		System.out.println(fixation.getSalary(5));
    				
    		//小时工对象创建
    		
    		HourEmployee hourEmployee=new HourEmployee(8,180,15);
    		System.out.println(hourEmployee.getSalary(8));
    		
    		//销售经理对象创建
    		SalesManager salesManager=new SalesManager(10,8000,10000,0.3);
    		System.out.println(salesManager.getSalary(10));
    		
    		
    
    	}
    
    }
    

    2.抽象类的使用:

    编写一个台灯测试;有台灯和灯泡,灯泡多个,台灯一个,台灯打开后点亮相应灯泡。
    分析,用抽象类规定统一标准来规范红绿灯灯泡类
    抽象父类灯泡 TableLamp 类:

    package com.zhiyou.abstactwork;
    /**
     * 台灯类
     * @author XiaoHui
     *	包含属性为一个灯泡类
     */
    public class TableLamp {
    
    	//创建一个Bulb类型的对象
    	private Bulb bulb;
    
    	//空构造函数
    	public TableLamp() {
    	}
    	
    	//构造函数来获取用户想要使用的灯泡的父类Bulb,此时如果传入子类灯泡,直接向上转型
    	public TableLamp(Bulb bulb) {
    		super();
    		this.bulb = bulb;			//令传入bulb赋值给本类创建的bulb
    	}
    	
    	public void on(){
    		System.out.println("台灯打开......");
    		bulb.shine();				//调用bulb的发光方法
    	}
    }
    

    子类 GreenBulb 类:

    package com.zhiyou.abstactwork;
    
    public class GreenBulb extends Bulb {
    
    	//重写父类发光方法
    	@Override
    	public void shine() {
    		System.out.println("绿灯泡发绿光....");
    	}
    }
    

    子类 RedBulb 类:

    package com.zhiyou.abstactwork;
    
    public class RedBulb extends Bulb {
    
    	//重写父类发光方法
    	@Override
    	public void shine() {
    		
    		System.out.println("红灯泡发红光.....");
    	}
    }
    

    台灯类 TableLamp 类:

    package com.zhiyou.abstactwork;
    /**
     * 台灯类
     * @author XiaoHui
     *	包含属性为一个灯泡类
     */
    public class TableLamp {
    
    	//创建一个Bulb类型的对象
    	private Bulb bulb;
    
    	//空构造函数
    	public TableLamp() {
    	}
    	
    	//构造函数来获取用户想要使用的灯泡的父类Bulb,此时如果传入子类灯泡,直接向上转型
    	public TableLamp(Bulb bulb) {
    		super();
    		this.bulb = bulb;			//令传入bulb赋值给本类创建的bulb
    	}
    	
    	public void on(){
    		System.out.println("台灯打开......");
    		bulb.shine();				//调用bulb的发光方法
    	}
    }
    

    测试类:TableLampTest 类:

    package com.zhiyou.abstactwork;
    
    public class TableLampTest {
    
    	public static void main(String[] args) {
    
    		//此时实例化一个红灯泡对象属于灯泡的子类;
    		RedBulb redBulb=new RedBulb();
    
    		//本来TableLamp()括号内传值为父类(Bulb),此处直接利用子类RedBulb
    		//子类对象向父类转型是向上转型,可以直接转型
    		TableLamp tableLamp=new TableLamp(redBulb);
    		tableLamp.on();
    		
    	}
    
    }
    

    3. 自写工具类:Date <-> String Number <-> String

    • 日期工具类

          /**
       * 日期工具类,实现日期与字符串互转
       * @author XiaoHui
       *	dateToString(Date date,String Pattern)
       *	stringToDate(String toDate ,String Pattern)
       */
      package com.zhiyou.util;
      
      import java.text.ParseException;
      import java.text.SimpleDateFormat;
      import java.util.Date;
      
      public class DateTool {
       
      private static SimpleDateFormat sdf=new SimpleDateFormat();
      
      public static String dateToString(Date date,String Pattern){
      	
      	sdf.applyPattern(Pattern);
      	return sdf.format(date);
      }
      
      public static Date  stringToDate(String toDate ,String Pattern) throws ParseException{
      	sdf.applyPattern(Pattern);
      	 return  sdf.parse(toDate);
       }
      
      }
      
    • 数字工具类

              package com.zhiyou.util;
          /**
           * 数字工具类
           *  @author XiaoHui
           *	numToString(Number num,String Pattern)
           *	stringToNum(String toNum,String Pattern)
           */
          import java.text.DecimalFormat;
          import java.text.ParseException;
          
          public class NumberTool {
          
          	private static DecimalFormat df=new DecimalFormat();
          	
          	public static String numToString(Number num,String Pattern){
          		df.applyPattern(Pattern);
          		return df.format(num);
          	}
          	public static Number stringToNum(String toNum,String Pattern) throws ParseException{
          		df.applyPattern(Pattern);
          		return df.parse(toNum);
          	}
          }
      
      

    展开全文
  • web开发学习周记(准备工作) 经过6周的学习,python方面有了一定基础之后,瞄准web前端,在专业人士的帮助下开始深入学习。 这周做的是前期的准备工作,包括搭建环境,选择合适的工具和掌握基本的操作方法。 Ace...

    web开发学习周记(准备工作)

    经过6周的学习,python方面有了一定基础之后,瞄准web前端,在专业人士的帮助下开始深入学习。

    这周做的是前期的准备工作,包括搭建环境,选择合适的工具和掌握基本的操作方法。

    Ace Admiin
    Ace中包含了许多框架模板,随便点开一个,里面的代码都是洋洋洒洒几百行,刚刚接触学习有些困难。
    Ace的框架是用HTML语言书写的,并运用CSS和Javascript对框架进行修饰。HTML是标记语言,用于构建网页的框架,是最基础,最根本的东西。CSS主要定位页面元素的样式,比如说高、宽、字体颜色等。Javascript是客户端脚本语言,主要完成页面的交互,行为。举个例子,页面就像房子,HTML就好比房子的钢筋骨架,CSS就像个房子粉刷、装修,Javascript就是给房子安装门窗、电视等。
    做web开发不需要专门学习HTML语言,只要能读懂代码,知道各个标签的用处即可。

    Navicat
    用于数据库的创建,需要额外搭建PostgreSQL数据库,用于Navicat的连接。

    web.py
    它是一个Python的web框架,通过web.py能把前端和后端联系起来,它是前期学习的重点。
    搭建一个简单的web.py开发框架:
    首先导入web模块:import web,之后要告诉web.py,URL如何组织,也就是定义一个URL映射。URL映射就是一个URL请求由哪块代码(类、函数)来处理。在定义了映射后,就要编写具体的请求,其中要用到GET(self)函数,表示当接收到一个GET请求时,上面的GET方法就会被web.py调用。最后,添加一行让web.py打开网页的代码,这个简易的开发框架就搭建完成了。
    具体代码如下:

    import web
    
    urls = ('/', 'index')
    
    class index:
        def GET(self):
            return "Good Morning!"
    
    if __name__ == "__main__":
        app = web.application(urls, globals())
        app.run()

    运行之后不要直接复制python给出的网址,需要做出一些更改,改为:http://localhost:8080/
    在这里插入图片描述

    在这里插入图片描述
    这周主要做的就是熟悉软件,熟悉环境,自己动手做些简单的测试,之后的学习任务将在下一周进行。

    展开全文
  • 1、io流 、数据流等等 outpustream(XXX,true) args[0] serialaizabl 等用法 2、开始思考 理清 dao类的代码数据 3、界面 gui component的各分类 actionlistener 监听器 4、完成图书属性部分的代码 ...

    1、io流 、数据流等等 outpustream(XXX,true) args[0] serialaizabl 等用法

    2、开始思考 理清 dao类的代码数据

    3、界面 gui component的各分类 actionlistener 监听器

    4、完成图书属性部分的代码

    5、mysql的各类基本语句 主键约束,唯一约束 自身连接等 (大致了解了navicat 的用法)

    转载于:https://juejin.im/post/5ad492b45188255cb07d9752

    展开全文
  • 4.6-4.12一周总结 一眨眼,又一个星期从身边跨过去了。过去的一周里面,应该说快乐和悲伤并存,很多时候被弄的...生活中,很多东西都是相通的,偶尔去外面换换心情,那只是为了更好的去学习。就像今天去看艺术展览,

     4.6-4.12一周总结
    一眨眼,又一个星期从身边跨过去了。过去的一周里面,应该说快乐和悲伤并存,很多时候被弄的很沮丧,很多时候又很兴奋。反正不管怎么样,既然已经决定了要走软件编程这条路,我就应该义无反顾,放下所有的包袱,认真努力的学一回。
    今天,虽然没有去学习,去了艺术展览馆,但不觉得浪费了。生活中,很多东西都是相通的,偶尔去外面换换心情,那只是为了更好的去学习。就像今天去看艺术展览,虽然很多东西都看不懂,但是增长了见识。感觉生活是多么的美好,生活中看似平凡的东西,艺术家的眼光就会变得很美好,所以认真的感知生活,那么自己就会变得很快乐。
    不过这一周,还是有很多不尽如人意的地方,比方说,自己订的誓言,实行了几天,一碰到困难就变卦了。还有学习上,一碰上困难,总是不想着怎么解决,而总是等着别人。这种学习态度是很悲观的,学习是快乐的事情,碰上困难了,应该高兴,说明自己又找到问题了,又有进步的空间了。所以,学习上,态度很重要。
    总结下上个星期的知识点吧:
    1.枚举(实际上就是个普通类)用enum表示。
    以前的方法:
    1. 用数字来代表那个属性,那个东西。 public static final int SPRING=0;
    主要是当所调用的这个数字超过了这个数字时,就会造成数据的不安全。
    2. 5.0以前的版本枚举   public staticfinal Season SPRING=new Season(”hello”);
    并且将方法定义为私有。Private Season(){};而且不能用在switch结构中。
     3.  5.0以后的枚举 定义一个enum类 SPRING(”hello”);并且可以用在switch结构中,可以用switch(this){case SPRING:return "春季";}如果要得到定义中的枚举常量时候,可以用Season[] s=Season.Values();    for(int i=0;i<ss.length;i++){System.out.println(ss[i]);}

    2.内部类(静态内部类,成员内部类,局部内部类,匿名内部类)
    1.静态内部类:就相当于此类的静态属性,想要访问,不需要对象,只要类名。属性就好了。所以静态内部类只能访问外部类的静态属性。(跟外部类的关系相当于是寄居,所致在生成内部类对象的对象时不需要有外部类对象)
    调用方法:OuterA.InnerA  inn=new OuterA.InnerA();     inn.m1();
    2.成员内部类:相当于类里边的实例属性或实例方法。与外部类的关系相当于是寄生,就是在生成内部类对象时必须要有外部类对象,。
    调用方法:OuterA out=new Outer();
      OuterA.InnerB innb=out.new InnerB();     innb.m2();
    3.局部内部类:在外部类的方法里边所定义的类。可以访问外部方法的final变量(相当于将那个常量拍个照,然后返回),也可以在里边直接调用外部类方法。
    调用方法:先定义一个接口interface MyInter{public void innerm();}
    public MyInter m1(){
    final int a=10;
    class InnerC implements MyInter{        //内部类中实现这个接口
    public void innerm(){ //实现接口的方法
    System.out.println("InnerC Innerm()!");
    System.out.println(a);
    }
    }

    return new InnerC(); //
    }
    主方法里边的调用OuterB out=new OuterB();   
             MyInter obj=out.m1();
             obj.innerm();
     4.匿名内部类:是一种特殊的局部内部类,它的语法比局部内部类灵活。
    先定义一个接口interface MyInter{public void innerm();}
    public MyInter m2(){
    return new MyInter(){           //定义了一个MyInter的无名实现类,并实现方法
    public void innerm(){
    }
    };
    }
    在内部类中访问外部类的方法:外部类名。this。方法
    3.集合框架collection(List有序列表Set无序集合Queue队列) Map映射
    1.List 元素有序存放,允许重复,实现类有ArrayList(线程不安全)及Vector(线程安全)和LinkedList(实现了List和Queue接口)。
    数组:访问效率高,但是插入,删除麻烦。
    链表:访问效率低,但是插入,删除简单。
    (迭代器:Iterator it=list.iterator();  Iterable接口里边的iterator方法返回的是一个Iterator类型,所以可以调用Iterator里边的方法。While(it.hasNext()){syso:(it.next());
    所有Iterator接口的实现类对象和所有的数组又都可以用for each方法:
    for(Object obj:list){obj};)
    2.Set 不允许重复,实现类HashSet。在实现Set.add(obj)时,先要求出这个对象的obj.hashCode();但是Object里边的方法返回的都是在内存中的地址,所以要覆盖toString方法。然后根据哈希运算求得下表位置,所以要覆盖hashCode()方法,如果判断了改下标上有对象的话,再调用equals方法,所以要覆盖Object里边的equals方法。
    还有个子接口SortedSet(排好序的集合)实现类TreeSet。因为是排好序的集合,那当然要有个排序的方式。有两种方法:1.实现Comparable接口,覆盖compareTo方法,一个类实现了Comparable接口这个类就有了自然顺序。2.定义一个内部类实现Comparator接口,实现compare方法。Public comparator=new 外部类。内部类构造器();
    3.Map 实现类HashMap(线程不安全)及HashTable(线程安全) (Set本质上就是一个Map,只是它右边的值没有了,就有一些键,所以Map的例子可以参照Set)
    子接口SortedMap实现类TreeMap
    Set set=map.keySet();
    Iterator it=set.iterator();
    While(it.hasNext()){
    Object obj=it.next();
    System.out.println(obj+”:”+map.get(obj));}



    上个星期总体上,学的东西还是能够掌握的,也只是用的不多,所以知识点也还是有点没串起来。也就是说,整体上,最困难的入门阶段我已经度过去了,所以一切都不要太悲观了,每天都抱着快乐的态度去学习。把学习当成是一种乐趣,每当掌握一个知识点,都兴奋的要命。Juxy,trust yourself,you will do best。

    展开全文
  • 周记

    2019-09-19 23:43:37
    根据这周学校,对自己的学习做出了总结。Java是我一直都需要认真学习的专业。 对于Java的学习,我个人认为这门课程在专业课里算是对以后的学习是比较重要的,应为不管以后选择什么专业,没有Java打基础是不行的。这...

    根据这周学校,对自己的学习做出了总结。Java是我一直都需要认真学习的专业。

    对于Java的学习,我个人认为这门课程在专业课里算是对以后的学习是比较重要的,应为不管以后选择什么专业,没有Java打基础是不行的。这周学习的是Java数组,虽然老师讲的很清晰也容易懂,但是我有些代码也记的不牢,所以导致有些地方的不是太清楚,学习也是有点吃力。我决定要在学习期间上课认真听老师的讲解,特别是课后的联系和上机的题目,以及老师提供给我们的有关学习编程语言的方法和技巧,对于我巩固所学的理论知识有很大的帮助。以后还会在很长的一段的过程需要我们更加努力的去学习。毕竟知识是靠积累才能真正掌握。在今后的学校方面还应该提高自己,努力掌握知识。在今后的学习,应该更佳努力。提高自己的成绩和知识水平。对今后选择专业和工作也可以有正确的抉择。

    在学习Java的语法时,Java的语法是类似c语言的,所以学习的比较轻松。唯一需要注意的是有几个不容易搞清楚的关键字的用法,public,protected,private,static,什么时候用,为什么要用,怎么用,和同学一起讨论了好久才得以解决。

    此外,我对于static,public,private,Exception,try{ },catch { },finally{ }等等一开始都不是很懂,都是把书上面的例子运行成功,然后就开始破坏它,不断的根据自己心里面的疑问来重新改写程序,看看能不能运行,运行出来是个什么样子,是否可以得到预期的结果。这样虽然比较费时间,不过一个例子程序这样反复破坏几次之后。我就对这个相关的知识彻底学通了。有时候甚至故意写一些错误的代码来运行,看看能否得到预期的运行错误。这样对于编程的掌握是及其深刻的。

    转载于:https://my.oschina.net/u/3824346/blog/1799328

    展开全文
  • Java web实习笔记目录导航 1. Java Web 实习笔记(一) 2.Java Web 实习笔记(二) 3.Java Web 实习笔记(三) 4.Java Web 实习笔记(四) 三层架构+MVC ...1.一种WEB层应用开发的一种设计思想,它把WEB应用分为三...
  • JavaWeb学习笔记19--Maven

    2020-05-14 08:26:01
    Maven是一个软件项目管理的综合工具。基于项目对象模型(POM)的概念,提供了帮助管理构建、文档、报告、依赖、发布等方法,Maven简化和标准化项目建设过程。
  • 1.eclipse中的server卡选项中找不到Tomcat选项,原因是在安装插件的时候少安了东西http://blog.csdn.net/fengpojian/article/details/70171327
  • Java学习周记week03

    2019-09-25 22:08:59
    一.继承 1.什么叫继承? 继承是面向对象的三大特征之一。 在程序中,继承描述的是类与类之间的关系,通过继承多个类之间形成一种关系体系。...在Java中,类的继承是指在一个现有类的基础上去构建一个新的类,构建出...
  • 1、HttpServletRequest和HttpServletResponse对象由Servlet容器负责创建,对于每一个HTTP请求,Servlet容器都会创建一个HttpServletRequest对象和HttpServletResponse对象。 2、Web服务器跟踪客户状态的四种常见...
  • http://www.cnblogs.com/xdp-gacl/category/574705.html
  • 通过不断面试和笔试,我逐渐发现基础的重要性,万丈高楼平地起,我又重新回来学习一下JSP+servlet基础了,很多基础没弄明白,后面框架就一脸蒙蔽,只能死记硬背。 什么是jsp? 其实本质就是html嵌套java代码。是...
  • 本人是javaweb,如果有同样方向的同学,看到下面的不了解的名词时尽量能够查一下看一看,应该在工作中会接触到。谢谢大家! 1.rewriteBatchedStatements = true 驱动才会帮你批量执行SQL  需要注意的是,即使...
  • 实习java web第二天

    2018-01-04 15:05:46
    今天学习了关于ps如何抠图 1. PS界面介绍 PS简介 Adobe公司 PS AI DW Indesign spark PR AE XD ps的功能: 图像处理(影楼后期、人像修复美化) 排版(书籍、杂志、喷绘、广告) 网页、APP版面设计...
  • 暑假周记

    2019-07-03 01:12:27
    学习了oracle的一些基本知识,在我要自学网上找的教学视频,学习了oracle的概述安装以及表空间的概念创建,用户的概念和创建,角色的创建,以及怎么为用户赋予权限,删除权限等。以及对表空间的管理,还学习了sql...
  • Java Web(SSM框架)环境搭建java1.8安装 java1.8安装 下载1.8版本Java jdk后打开安装
  • 14~15号游走于各大网站,看前端的基本体系,结论是东西比较新,尚未稳定。 面经总计: (1)转行学生:项目支撑、复现项目时突出亮点、创造性工作 (2)基础内容掌握:计算机、网络、数据结构 (3)例如jvm方面,...
  • 暑假周记

    2019-07-03 01:12:28
    学习oracle的知识时不怎么困难,主要是sqldeveloper的使用上有问题,刚开始下载了最新版本的sqldeveloper,总是连接不上,在网上找了很多办法也不管用,后来在网上 看到说是最新版本的连不上oracle数据库,于是下载...
  • 周总结

    2018-07-09 22:03:31
    用户注册实例2.JSP 练习3.JSP 内置对象二、 本周总结本周开始了Javaweb学习,在这一周完成了对其中JSP的学习,并运用JSP完成了一个简单的学生管理系统,可以完成学生信息的增删改查,总的来说还是很有意思的,其中...
  • 怎么看懂一个复杂的程序 1.先看需求,只有了解了程序的想要解决的问题,才能明白程序的做法的意义在哪里。 2.看完需求看数据库架构,数据库就像中间的目标,程序每一阶段的目标都是为了将数据弄进数据库,数据库的...
1 2
收藏数 29
精华内容 11