第四周周报

代码块的优先级排序；

静态代码块>构造代码块>构造方法

什么是继承？继承的特点以及好处是什么？

继承：将多个类的共性内容，抽取到一个独立的类中，让多个类和独立的类产生一种关系

特点：提高代码复用性；

提高代码维护性；

继承的关系，是多态的前提条件；

只支持单继承，不支持多继承，但可以多层继承；

Static关键字的特点？

随着类的加载而加载，

优先于对象存在，不能和this共用；

具备共享，共用的意思，如果需求中有共享，共用的这个意思，这时候需要将变量定义static

被静态修饰的变量以及方法都直接类名访问

类名.方法名；

成员变量和静态变量的区别?

存储位置不同；

成员变量：堆内存汇总；

静态变量：static静态区；

生命周期不同；

成员变量：随着对象的创建而存在，随着对象的创建完毕等待垃圾回首而消失；

静态变量：随着类的加载而存在，随着类的加载结束而消失

初始化不同：

成员变量：他可以不初始化，存在默认初始化，通过setXXX（XX）或者有参构造放法显示初始化

静态变量：也可以不初始化，或者直接初始化

给成员变量赋值的方式有几种：

类的seXXX（）方法赋值

通过构造方法

继承的弊端，什么时候使用继承？

继承的弊端 :具有局限性,继承了一个类,可以将这个类里面的所有的非私有的方法继承过来,有的功能不需要
不能为了使用类的部分功能,去使用继承!
使用继承的时机:当类A是类B的一种或者类B是类A的一种,使用继承 ,体现 "is a"的关系

什么是继承?继承的特点以及好处分别是什么?
继承:将多个类的共性内容,抽取到一个独立的类中,让这个多个类和独立的类产生一种关系!(extends)
继承的特点:
        1)提高代码的复用性
        2)提高代码的维护性
        3)继承的关系(类与类之间),是多态的前提条件
继承:只支持单继承,不支持多继承,但是可以多层继承!

子类继承父类,如何访问父类构造方法?

子类所有的构造方法默认访问父类的无参构造方法(子类所有构造方法的默认第一句话:隐藏super())
父类中没有给出无参构造方法,只存在有参构造方法,子类的所有构造方法会报错,如何解决
 1)给出父类的无参构造方法

 2)让子类的所有的构造方法,显示的访问父类的有参构造方法(让父类先数据初始化）

  3)子类中的某一个构造方法能够让父类初始化即可!

1.继承的注意事项(重点)
1)子类继承父类,继承父类的非私有的成员,私有的成员,可以间接访问!
2)子类继承父类,构造方法是不能继承的,通过一个关键字来访问  super()  (在继承 super的使用)

 2. 继承的成员变量访问问题(重点)
1)子类继承父类,如果子类和父类的成员变量名称不一致,(分别访问即可)
2)子类继承父类,子类和父类的成员变量名称一致,访问(采用"就近原则")

3.继承的构造方法访问问题 :super来访问(重点)
1)子类继承父类,子类的所有构造方法的默认第一句话都super() ;(可以省略的不写) 访问父类的无参构造方法
2)如果父类中没有给出无参构造方法, 那么会出现什么情况?如何解决?

 4.继承的成员方法访问问题
子类继承父类, 如果子类和父类的成员方法名称不一致,分别调用即可
如果如果一致,而且一模一样,方法重写Override (方法覆盖/方法复写),重写的时候必须要保证它的访问权限足够大!

什么是方法重写?
Override,在继承关系中,子类出现了一摸一样的方法声明(权限修饰符,返回值类型,方法名,参数列表都相同),子类将父类的方法覆盖了,实现自己的业务逻辑..

子类重写父类的方法是需要注意什么？

重写方法不能比被重写方法限制有更严格的访问级别。

 参数列表必须与被重写方法的相同。

返回类型必须与被重写方法的返回类型相同。

不能重写被标识为final的方法。

如果一个方法不能被继承，则不能重写它

⼦类不能⽤ 静态⽅法 重写⽗类的⾮静态⽅法

⼦类不能⽤⾮静态⽅法 重写 ⽗类的静态⽅法

final关键字的特点
final修饰类,该类不能继承
final修饰变量,此时变量是一个常量(自定义常量)
            编译时期常量:(jvm不需要加载)   public static final 基本数据类型 变量名 = 值;
            运行时期常量:(jvm需要加载)     public static final 引用数据类型 变量名 = new  xxx();
final修饰成员方法,该方法不能被重写           

什么是多态,多态的前提条件以及成员访问特点?

多态的前提条件
    1)必须有继承关系
    2)存在方法重写
    3)必须父类引用指向子类对象
成员访问特点:
父类名 对象名 = new  子类名();
    1)成员变量(非静态):编译看左,运行看左!
    2)成员方法(非静态):编译看左,运行看右(因为子类存在重写)
      静态的成员方法:算不上方法重写,跟类相关,类名.静态方法名() ;  编译看左,运行看左!
    3)构造方法: 由于存在继承关系,分层初始化(先让父类初始化,然后再是子类初始化!)

多态的好处以及弊端,针对弊端如何解决?
多态的好处:
    1)提高代码扩展性(父类引用指向子类对象),多态保证
    2)提高代码的维护性以及复用性(由继承保证)
多态的弊端:
    无法访问子类的特有功能!
    解决方案:
   1)直接创建具体的子类对象
    子类名 对象名 = new 子类名() ; (不推荐),从内存角度考虑,又需要开辟堆内存空间
    2)推荐向下转型---前提条件:必须存在向上转型((父类引用指向子类对象))    
           父类名 对象名 = new  子类名();
                    
           子类名 子类引用 =  (子类名)对象名; 强转类型转换的格式）

抽象类和接口的区别？

1.抽象类允许包含某些方法的实现，而接口是不允许的；
2.在抽象类中提供成员方法的实现细节，该方法只能在接口中为 public abstract修饰，也就是抽象方法。
3.抽象类中的成员变量可以实现多个权限 public private protected final等，接口中只能用 public static final修饰。

this和super的区别?

1)概念的区别
    this:代表的当前类对象的地址值引用
    super:代表的父类的空间表示(父类对象的地址值引用)
2)使用不同
    2.1)针对成员变量访问
        this.变量名 ; 访问的本类的成员变量
        super.变量名; 访问的父类成员变量
    2.1)访问构造方法
        this() ; 访问本类的无参构造方法
        this(xx); 访问本类的有参构造方法
        super() ;访问父类的无参构造方法
        super(xx);访问父类的有参构造方法
    2.2)访问成员方法
        this.方法名() ;访问本类的成员方法
        super.方法名() ;访问父类的成员方法

什么是抽象类?

有抽象方法的类一定是抽象类；（将事物的通用行为-->仅仅给出一个声明,抽象方法,没有方法体）
抽象类的最大特点:
        1)强制子类必须完成的事情(将抽象类中的抽象方法必须重写)
        2)不能实例化(不能创建对象)
        3)实例化---通过抽象类多态(抽象类的子类--->一定会有一个具体类)

抽象类的成员特点        
        1)成员变量:皆可以变量,也可以常量
        2)成员方法:可以抽象方法,也可以存在非抽象方法
        3)构造方法:无参/有参构造都存在,因为存在继承关系, 还需要分层初始化的
什么是接口：接口体现的是这个事物本身不具备的工具，额外的功能
接口定义：interface 接口名{}
接口的特点：
接口的方法不能有具体的方法体；只能是抽象方法，而且隐藏了public abstract
接口不能实例化，
接口的实现类是一个抽象类，肯定有具体的接口的实现类来new对象
接口名 对象名=new 具体的子实现类（）
开发中定义接口的实现类名
class 接口名IMPL implements（实现）接口名{}
接口的成员特点：
成员变量：只能是常量 存在默认修饰符public abstract final（可以省略）
成员方法：只能是抽象方法，存在默认修饰符public abstract（可以省略）
构造方法：接口没有构造方法；

关于类与类，接口与类，接口与接口的关系；
类与类：只支持单继承，不支持不支持多继承，但可以多层继承；
接口与类：实现关系
接口与接口：接口与接口之间是继承关系（可以是单继承亦可以是多继承）
面试题：接口与抽象类的区别？
成员的区别:
抽象类
成员变量;既可以是常量，也可以是变量；
成员方法;既可以是抽象方法，也可以是非抽象方法
构造方法：无参/有参构造都存在，子类父类继承，需要分层初始化
接口
成员变量：只能是常量public static final（默认修饰符）
成员方法：只能是抽象方法 public abstract（默认修饰符）
构造方法：没有----需要借助子实现类进行实例化

abstract不能和哪些关键字使用
应用范围:
        抽象类 abstract class类名{}
        抽象方法 public abstract 返回值类型 方法名(空参/有参) ;

abstract不能和private
abstract不能和static
不能和final

静态的成员内部类的特点
 成员内部类---还可以static修饰符(记忆)
       1)静态的成员内部类只能外部类的静态成员!
       2)静态的成员内部类中无论是静态方法还是非静态方法:访问外部类的成员必须静态
       3)想直接通过外部类来访问静态成员内部类的成员信息,访问格式
               外部类名.内部类名  对象名 =  new 外部类名.内部类名()

权限修饰符的默认修饰符private/默认修饰符/protected/public
在同一个包下的同一个类中访问权限都一样；
在同一个包下的子类中除了pritate其他都可以访问；
在同一个包下的无关类中（同上）
在不同包下的子类中只有public和protected可以访问
在不同包下的无关类中只有public可以访问
一个包下只能有公共类

内部类
成员内部类：成员内部类可以访问外部类成员，包括私有相关的；
外部类直接访问内部类的成员
外部类.内部类 成员对象=new 外部类().new内部类（）；
成员内部类的修饰符：
可以有private修饰（保证数据安全性）
还可以有static修饰符（静态的成员内部类只能访问外部类得静态成员）
静态的成员内部类中无论是静态方法还是非静态方法，访问外部类的成员必须静态；
想直接通过外部类来访问静态成员内部信息，访问格式
外部类名.成员内部类名 对象名=new 外部类名.内部类名（）；

形式参数是一个接口,

调用方法的时候 , 实际参数应该传递接口的子实现类对象 !( 接口多态 )

abstract interface Person{
    public abstract void work() ;
}
class PersonDemo{
    public void show(Person p){
        p.work();
    }
}
class Progammer implements Person{
    @Override
    public void work() {
        System.out.println("程序员日日夜夜敲代码...");
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        Person p = new Progammer() ;
        pd.show(p);
    }
}
//方法二，使用匿名内部类
abstract class Person{
    public abstract void work() ;
}
class PersonDemo{
    public void show(Person p){
        p.work();
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        pd.show(new Person() {//匿名内部类的使用
            @Override
            public void work() {
                System.out.println("人都需要工作...");
            }
        });
    }
}
------------------------------------------------------------
interface Person{
    public abstract void work() ;
     //接口中有且仅有一个抽象方法,这个接口称为"函数式接口"
 }
 

class PersonDemo{
    public void show(Person p){
        p.work();
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        pd.show(
                ()-> {
            System.out.println("要结婚了,很开心...");
        }
);
    }
}

形式参数是一个抽象类,

调用方法时 , 实际参数需要传递该抽象类的子类对象 ( 抽象类多态 )

abstract class Person{
    public abstract void work() ;
}
class PersonDemo{
    public void show(Person p){
        p.work();
    }
}
class Progammer extends Person{
    @Override
    public void work() {
        System.out.println("程序员日日夜夜敲代码...");
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        Person p = new Progammer() ;
        pd.show(p);
    }
}
//使用匿名内部类
interface Person{
    public abstract void work() ;
}
class PersonDemo{
    public void show(Person p){
        p.work();
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        pd.show(new Person() {
            @Override
            public void work() {
                System.out.println("人都需要工作...");
            }
        });
    }
}

方法的返回值是一个接口,

该方法结束需要返回该接口的子实现类对象 ( 接口多态 )

interface Person{
    public abstract void Work() ;
}
class PersonDemo {
    public Person show() {
        return new Person(){
            @Override
            public void Work() {
                System.out.println("我爱高圆圆");
            }
        };
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
        Person person=pd.show();
        person.Work();
        System.out.println("-----------------------");
        new PersonDemo().show().Work();//匿名对象

    }
}

返回值是一个抽象类

该结束需要返回该抽象类的子类对象 ( 抽象类多态 )

abstract class Person{
    public abstract void Work() ;
}
class PersonDemo {
    public Person show() {
        return new Person(){
            @Override
            public void Work() {
                System.out.println("我爱高圆圆");
            }
        };
    }
}
public class ArgsDemo {
    public static void main(String[] args) {
        PersonDemo pd = new PersonDemo() ;
       Person person= pd.show();
              person.Work();
System.out.println("-----------------------");
        new PersonDemo().show().Work();//匿名对象调用
    }
}

外部类如何直接访问静态成员内部类的成员?

外部类名.内部类名 对象名 = new 外部类名.内部类名() ;

对象名.静态成员内部类的成员;

如果静态的成员内部类的成员方法也是静态的:

外部类名.内部类名.静态方法名()

;

静态的成员内部类里面的成员方法无论是静态还是非静态的访问外部类的成员必须为静态!

匿名内部类

匿名内部类: 没有名字的类

应用范围: 在局部位置中的(方法定义中或者声明上)

匿名内部类的格式:

new 类名或者一个接口名(){

重写方法(){

...

}

}

匿名内部类的本质:就是继承该类(抽象类)或者是实现类了该接口的子类对象

选择排序：

public class ArrayTest {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入五个整数:");
        int arr[]=new int[5];
        int j = 0;
        for(int i=0;i<arr.length;i++) {
            int num = sc.nextInt();
            j=i;
            arr[j]=num;
        }
        Array(arr);
        Arr2(arr);
        }
//把键盘录入的数据储存在数组中

   public static void Array(int[] arr1) {
       System.out.print("[");
       for (int i = 0; i < arr1.length; i++) {
           if (i == arr1.length - 1) {
               System.out.print(arr1[i] + "]");
           } else {
               System.out.print(arr1[i] + ",");
           }
       }
   }//遍历数组
    public static void Arr2(int[] arr2){
        for (int i=0;i<arr2.length-1;i++){
            for (int y=i+1;y<arr2.length;y++){
                if(arr2[i]>arr2[y]){
                    int temp=arr2[i];
                    arr2[i]=arr2[y];
                    arr2[y]=temp;
                }
            }
        }
        Array(arr2);
    }
}//选择排序

. 常用类之Object的getClass方法

面试题:

在Java中获取一个类的字节码文件对象的方式有几种?

三种方式

public Ũnal Class getClass() 任意java对象调用getClass()

任意Java类型的class属性

Class类有一个静态方法 forName("包名.类名")