javaDay02-面向对象语法-CSDN博客

本文链接：https://blog.csdn.net/Geass_Monster/article/details/113257300

1.private 私有，只能在本类中进行访问。

2.局部变量与成员变量重名时，变量遵循就近原则。（先在方法找，没有就去成员变量找）
例：

public class MyTest {
    public static void main(String[] args) {
        Star star = new Star();
        //局部变量
        star.show("林俊杰");
    }
}

class Star{
    //成员变量
    String name="陈奕迅";
    public void show(String name){
        System.out.println(name);

    }
}

//输出的结果为：
//林俊杰

3.静态变量只有一份，存在方法区内的静态区。

4.构造方法：new对象的时候使用，作用是可以给新对象的成员变量赋值。

5.static：

可以修饰成员变量，可以修饰成员方法
修饰成员变量，此变量为共享变量，被该类的所有对象所共享，只有一份数据
被static所修饰的方法，在方法内部只能访问静态成员，不能访问非静态成员
在静态方法中不能出现this关键字
被静态所修饰的成员，推荐使用类名去调用

6.代码块：

局部代码块：定义在方法中。
构造代码块：类中，构造方法之前。每次new对象都会调用。
静态代码块：static{} 随着类加载而加载，只执行一次
举例：

class Student{
    static{
        System.out.println("Student 静态代码块");
    }
    {
        System.out.println("Student 构造代码块");
    }
    public  Student(){
        System.out.println("Student 构造方法");
    }
}
public class StudentDemo {
    static {
        System.out.println("StudentDemo 静态代码块");
    }
    public static void main(String[] args) {
        System.out.println("我是main方法");
        Student student = new Student();
        Student student1 = new Student();
    }
}

执行结果为：
StudentDemo 静态代码块
我是main方法
Student 静态代码块
Student 构造代码块
Student 构造方法
Student 构造代码块
Student 构造方法

7.继承

单继承，多层继承。
只能继承非私有类
new子类对象时，会先调用父类构造
子类重写父类方法时，权限不能低于父类。（能用老子就能用儿子）（public>protected>缺省>私有）
final：被修饰类不能继承；被修饰方法不能重写；被修饰量不能重新赋值

8.多态

new子类对象，用父类收。
方法运行重写的，其他都是父类的。
采用向下转型拿子类自己的。

9.抽象

抽象类中可以有非抽象方法，子类继承使用就行，抽象方法强制子类必须全部重写。
有构造。
不能直接创造对象，采用多态。
子类也是抽象类，就可以不重写父类的抽象方法。
abstract不能与final共存，一个要子类重写，与一个不允许继承重写；不能与private共存；不能与static共存。

10.接口

特殊抽象类
只能有抽象方法。默认public abstract
变量默认 public static final（可通过接口名直接调）
无构造
通过多态实例化对象
可以多继承。一个类实现（implements）多个接口，一个接口也可以继承（extends）多个其他接口。
jdk1.8以后，接口中可以有非抽象方法，加default（给出实现，子类可以直接使用），可以定义静态方法（接口名调用）。

11.内部类

（1）成员内部类

未修饰：Outer.Inner a=new Outer().new Inner();
等价于：Outer outer=new Outer();
Outer.Inner a=outer.new Outer();
private修饰：在外部类的成员方法中内部new出内部类经行操作，外部类直接调用此方法。
static修饰：Outer.Inner a=new Outer.Inner();
只能访问外部类静态成员。

（2）局部内部类

只能在这个内部类存在的方法中new出内部类的对象，再进行访问。
局部内部类，访问他所在方法的局部变量，这个局部变量必须为一常量。JDK以后，final会默认存在（传过来就不能再改，如果改了会报错）。

（3）匿名内部类

直接new父类，重写其中的抽象方法。

（4）内部接口

分私有和未私有。举例：

public class MyTest {
    public static void main(String[] args) {
       /* new Outer.A(){
            @Override
            public void show() {
                System.out.println("hahaha");
            }
        }.show();
        */
        Outer outer = new Outer();
        outer.outerShow();
    }
}
//外部类
class Outer{
    //内部接口
   private interface A{
        void show();
    }
    public void outerShow(){
       new A(){
           @Override
           public void show() {
               System.out.println("hihihi");
           }
       }.show();
    }
}