2018-12-03笔记

构造方法只可以在创建对象时调用，用于初始化对象；

 

在普通成员方法里面不可以this(“张三”);但是可以this.study();

 

super关键字代表父类对象；

 

在创建子类对象时，父类的构造方法会先执行，因为子类中所有构造方法的第一行有默认的隐式super();语句；

 

Super()父类构造方法

Super.study()父类中的study方法

Super.name父类对象中的name属性

 

在子类的构造方法中第一行默认有一个super()，默认调用父类的空参构造方法；

//不写也有，写也有

 

Super()必须要写在构造方法第一行；

 

为什么子类对象创建都要访问父类中的构造方法？因为子类继承了父类的内容，所以创建对象时，必须要先看父类是如何对其内容进行初始化的；

//初始化和清理，这里的作用就是初始化父类对象；

 

无论到哪儿，子类的构造方法都会有一个super()，用来初始化父类对象，所以在创建类时，务必要提供一个无参构造方法；

//如果父类没有无参构造，只有有参构造，那么super(传入实参);传入实参的super构造器也是可以的；

//只是走一下父类的构造方法；

//对父类的内容初始化；

 

那么，子类中的构造方法为什么会有一句隐式的super()呢？

原因：子类会继承父类中的内容，所以子类在初始化时，必须先到父类中去执行父类的初始化动作。这样，才可以使用父类中的内容。

当父类中没有空参数构造方法时，子类的构造方法必须有显示的super语句，指定要访问的父类有参数构造方法；

 

如果子类的构造方法第一行写了this调用了本类其他构造方法，那么super调用父类的语句还有吗？

这时是没有的，因为this()或者super(),只能定义在构造方法的第一行，因为初始化动作要先执行；

 

this和super关键字在构造方法中，只能在第一行，所以使用了this关键字之后，super就不存在了；

 

只要子类构造方法能够直接或者间接调用父类构造方法（无餐/有参）即可；

this()和super()只能写在构造方法中，在普通方法不可以有this()和super()，因为这两个是初始化对象的构造方法，只可以在创建对象时使用；在普通方法中使用this和super关键字则没有必须在第一行的要求，只有this()和super()这种形式要求必须在第一行；

 

父类构造方法中是否有隐式的super呢？

也是有的。记住：只要是构造方法默认第一行都是super();

父类的父类是谁呢？super调用的到底是谁的构造方法呢？

Java体系在设计，定义了一个所有对象的父类Object

 

类中的构造方法默认第一行都有隐式的super()语句，在访问父类中的空参数构造方法。所以父类的构造方法既可以给自己的对象初始化，也可以给自己的子类对象初始化。

如果默认的隐式super()语句在父类中没有对应的构造方法，那么必须在构造方法中通过this或者super的形式明确要调用的构造方法。

 

this功能：

①   调用本类的成员变量和成员方法

②   区分成员变量和局部变量同名问题

③   在构造方法中调用其他构造方法

 

Final用法：修饰类，类的成员，以及局部变量；不能修饰构造方法！

 

final修饰类不可以被继承，但是可以继承其他类！

final修饰的方法不可以被子类重写，但父类中没有被final修饰方法，子类重写后可以加final；

final修饰的变量称为常量，这些变量只能赋值一次，而且终身不变；

 

final修饰局部变量（基本数据类型），一旦赋值终身不变；

//静态常量才会变成蓝色（static final）

 

final修饰局部变量（引用数据类型），一旦赋值一个地址终身不变；

 

final修饰成员变量，需要在创建对象前初始化，负责报错；成员变量进堆，会给一个默认值，不手动赋值就没有意义了；要么手动赋值，要么构造方法赋值，只要在创建对象之前赋值就没问题，注意：SET方法是不可以的！！！

 

package com.oracle.demo04;

public class Person {

         //声明了常量之后，要么手动附初值，要么在构造方法中赋值，不可以在SET方法中赋值，因为常量要在创建对象分配地址之前赋值；

         final String name;

         public Person(String name){

                   this.name=name;

         }

}

 

package com.oracle.demo01;

public class Student {

         private String name;

         private static String Schoolname;

         public Student(){

                   super();

         }

         public Student(String name, String schoolname) {

                   super();

                   this.name = name;

                   Schoolname = schoolname;

         }

         public String getName() {

                   return name;

         }

         public void setName(String name) {

                   this.name = name;

         }

         public String getSchoolname() {

                   return Schoolname;

         }

         public void setSchoolname(String schoolname) {

                   Schoolname = schoolname;

         }

}

 

package com.oracle.demo01;

public class Test {

         public static void main(String[] args) {

                   Student s1=new Student("小红","清华大学");

                   Student s2=new Student("小明","清华大学");

                   Student s3=new Student("小亮","清华大学");

                   s2.setSchoolname("北京大学");

                   System.out.println(s1.getSchoolname()+"……"+s2.getSchoolname()+"……"+s3.getSchoolname());

         }

}

/*

 * 1.加载Test.class和Student.class

 *

 * 2.加载main方法和private static String Schoolname;进入方法与数据共享区（静态区）

 *

 * 3.main方法进栈，执行内容

 *

 * 4.new的对象进堆，由于Schoolname已经进入静态取，所以堆内只有String name

 *

 * 5.执行对象的构造方法，将小红赋值给堆中的String name，静态区中的Schoolname被赋值成清华大学

 *

 * 6.几个对象都是这个流程，最后把对象s2的学校改为北京大学，由于所有Student对象都指向这个静态区，所以所有对象都的Schoolname都变为北京大学了

 *

 * */

 

被static修饰的成员变量属于类，不属于这个类的某个对象（也就是说，多个对象在访问或修改static修饰的成员变量时，其中一个对象将static成员变量值进行了修改，其他对象中的static成员变量值跟着改变，即多个对象共享同一个static成员变量）；

被static修饰的成员可以并且建议通过类名直接访问；

静态内容是优先于对象存在，只能访问静态，不能使用this/super（本类对象/父类对象）；静态修饰的内容存于静态区；

同一个类中，静态成员只能访问静态成员（因为静态成员是和main方法一起出现的，静态成员出现的时候，普通成员还没出现）；

main方法为静态方法仅仅为程序执行入口，它不属于任何一个对象，可以定义在任意类中；

非静态成员可以访问静态成员，静态成员不可以访问非静态成员；

 

静态&多态：

package com.oracle.demo02;

public class Fu {

         static int i=1;

         public static void f(){

                   System.out.println("这是父类静态方法");

         }

}

 

package com.oracle.demo02;

public class Zi extends Fu{

         static int i=2;

         public static void f(){

                   System.out.println("这是子类重写后的方法");

         }

}

 

package com.oracle.demo02;

public class Test {

         public static void main(String[] args) {

                   Fu f=new Zi();

                   System.out.println(f.i);

                   f.f();

                   //多态特殊点：子类对象交给父类引用，此时静态成员变量和静态成员方法，都是调用父类的，因为此时成员变量和成员方法都属于类不属于对象

         }

}

 

使用public static final修饰的变量来定义静态常量；

 

定义格式：

public static final 数据类型 变量名 = 值;

 

接口中的每个成员变量都默认使用public static final修饰；

所有接口中的成员变量已是静态常量，由于接口没有构造方法，所以必须显示赋值，可以直接用接口名访问；

 

//当final修饰的成员变量必须在创建对象之前赋值，要么直接附初值要么用构造方法赋值；

 

匿名对象是指创建对象时，只有创建对象的语句，却没有把对象地址值赋值给某个变量；

//没有引用；

 

①   创建匿名对象直接使用，没有引用变量；

new Person().eat()

②   匿名对象在没有指定其引用变量时，只能使用一次；

new Person().eat()和new Person().eat()不是相同的对象；

③   匿名对象可以作为方法接收的参数，方法返回值使用；（作为实参传入某个方法，或者作为返回值使用）

 

什么是内部类

将类写在其他类的内部，可以写在其他类的成员位置和局部位置，这时写在其他类内部的类就称为内部类。其他类也称为外部类；

什么时候使用内部类

在描述事物时，若一个事物内部还包含其他可能包含的事物，比如在描述汽车时，汽车中还包含这发动机，这时发动机就可以使用内部类来描述；

 

①   成员内部类：在成员位置

②   局部内部类：在方法中

 

内部类的分类：

内部类分为成员内部类与局部内部类。

我们定义内部类时，就是一个正常定义类的过程，同样包含各种修饰符，继承与实现关系等；在内部类中可以直接访问外部类的所有成员；

 

成员内部类，定义在外部类中的成员位置。与类中的成员变量相似，可通过外部类对象进行访问

定义格式

class 外部类 {

         修饰符 class 内部类 {

                   //其他代码

}

}

 

访问方式

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

 

package com.oracle.demo04;

public class Outer {

         int i=0;

         //成员内部类

         class inner{

                   int i=2;

                   public void show(){

                            int i=1;

                            //1.成员内部类的成员方法，访问内部类中的成员变量，使用this关键字

                            //2.成员内部类的成员方法，访问外部类中的成员变量，使用外部类类名.this.成员变量名

                            Outer.this.show();

                            System.out.println(Outer.this.i);

                   }

         }

         public void show(){

                   System.out.println("这是外部类成员方法");

         }

}

 

package com.oracle.demo04;

public class Test {

         public static void main(String[] args) {

                   //创建Outer中成员内部类inner的对象，然后调用成员内部类的方法：

                   Outer.inner inn=new Outer().new inner();

                   inn.show();

         }

}

 

局部内部类：

局部内部类，定义在外部类方法中的局部位置。与访问方法中的局部变量相似，可通过调用方法进行访问

定义格式

class 外部类 {

         修饰符 返回值类型 方法名(参数) {

class 内部类 {

//其他代码

}

}

}

访问方式

在外部类方法中，创建内部类对象，进行访问

 

package com.oracle.demo05;

public class Outer {

         public void show(){

                   class Inner{

                            public void show2(){

                                     System.out.println("这是局部内部类的方法");

                            }

                   }

                   //局部内部类只能在创建类的方法内创建对象，然后调用方法，然后早main方法中创建外部类的对象，调用存在局部内部类的外部类的成员方法；

                   Inner in=new Inner();

                   in.show2();

         }

}

 

package com.oracle.demo05;

public class Test {

         public static void main(String[] args) {

                   Outer out=new Outer();

                   out.show();

         }

}