Java学习轨迹面向对象（持续更新）

Posted 2020-09-22

其中部分内容为其他博主所作，侵删 
6月12日-7月每日更新

Java学习轨迹 
一、面向对象 
类和对象 
1. new关键字所完成的事情 
1)为对象开辟了新的内存空间 
2)调用类的构造方法 
3)返回生成对象的地址 
Dog dog=new Dog(); 
dog是引用，new Dog()生成了一个Dog对象，引用dog指向所生成对象的地址

2.构造方法 
1)构造方法必须与类名相同 
2)构造方法没有返回值【且不能使用void作返回值】 
3)如果在定义类的时候没有为类声明构造方法java编译器会自动为类添加一个没有参数且方法体为空的默认构造方法,若声明了构造方法，则编译器不再自动添加默认构造方法 
4)不能显式的调用类的构造方法，通常是用new关键字隐式的调用构造方法，也就是在new一个对象的时候调用 
5)构造方法可重载：方法名相同，但参数不同，调用时会自动根据不同的参数选择相应的方法。 
3. 成员变量和局部变量 
1)成员变量不必赋初值，默认会赋上初值 
2)局部变量必赋初值

4.static的用法 
1)static静态变量（类成员） 
①它属于整个类所有，而不是某个对象所有，被类的所有对象所共享。 
②静态成员可使用类名直接访问，也可以使用对象名进行访问。 
③静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收。 
2)static静态方法（类方法） 
①静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。 
②如果系统在静态方法中调用非静态变量，可通过创建类的对象，然后通过对象来访问非静态变量。 
③在普通成员方法中，则可以直接访问同类的非静态变量和静态变量。 
④静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。 
static修饰的变量是类变量，只有一处内存空间，类变量一旦在其他方法被修改，类变量也会改变； 
static修饰的方法是类方法，当一个类创建一个对象后，就会调用这个类方法 
3)初始化块 
普通初始化块

    {
    /****
                 ****/
    }

静态初始化块

static{
    /****
                 ****/
    }

封装：即将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法类实现对隐藏信息的操作和访问。

1. 封装的好处：只能同规定的方法访问数据，隐藏类的实现细节，方便修改和实现。即（①降低耦合（关联）率②可重复调用类中的属性③提高安全性）
2. 实现封装的步骤： 
   1）修改属性的可见性（private），限制访问。 
   2）设置属性的读取方法（ 创建getter/setter方法）。 
   3）在读取属性的方法中，添加对属性读取的限制。（在getter/setter方法中加入属性控制语句：对属性值的合法性进行判断）
3. 访问修饰符：修饰属性和方法，设置权限 
   1)private：只能在本类中访问和使用。 
   2)默认：能在本类和同包中访问和使用。 
   3)protected：能在本类、同包、子类中使用。 
   4)public：在本类、同包、子类、其它类中使用。 
   注意：① final修饰的类不能被继承，没有子类。 
   　　 ②abstract修饰的类不能被实例化，必须被子类继承。类只要有一个抽象方法就必定是抽象类，但抽象类不一定要有抽象方法。 
   　　
4. this：代表当前对象
5. 内部类：一个类的定义放在另一个类的内部，这个类就叫做内部类。 （仍然是一个独立的类，在编译之后内部类会被编译成独立的.class文件，但是前面冠以外部类的类名和$符号 。） 
   使用内部类的好处： 
   1)内部类可以很好的实现隐藏，一般的非内部类，是不允许有 private 与protected权限的，但内部类可以 
   2)内部类拥有外围类的所有元素的访问权限（若内部类声明成静态的，就不能随便的访问外部类的成员变量了，此时内部类只能访问外部类的静态成员变量 。） 
   3)是实现多重继承 
   4)可以避免修改接口而实现同一个类中两种同名方法的调用。

内部类分为四种： 
①成员内部类：最普通的内部类【注意：定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去new一个内部类对象。】

public class Outer{
    int outi=0;
    private int prii=0;
    private class Inner{
    int inni=0;
    outi++;
    prii++;
    public void seeOut{
        System.out.println(outi+prii);
    }
}   
}

 

其中，Inner类中可以调用Outer类中的任意变量（outi,prii），而Outer类中不能调用Inner类的变量（inni） 
②方法内部类：把类放在方法内 
(1)、方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。 
(2)、方法内部类对象不能使用该内部类所在方法的非final局部变量。

public class Outer{
public void go(){
    final int outi=0;
    private class Inner{
        public void seeOut(){
        System.out.println(outi);
        }
    }
}
Inner in=new Inner();
in.seeOut();
public static void main(String[] args) {
    Outer out = new Outer();
    out.go();
}
}

这段代码供大家自行体会 
③静态内部类（由static关键字修饰） 
1)静态内部类不能直接访问外部类的非静态成员，但可通过”new 外部类().成员”的方式访问 
2)如果外部类的静态成员与内部类的成员名称相同，可通过”类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过”成员名” 直接调用。 
3)创建静态内部类的对象时，不需要外部类的对象，可以直接创建：内部类 对象名 = new 内部类();

public class Outer{
        static class Inner{}
}
public class{
        public static void main(String[] args){
                Outer.Inner n = new Outer.Inner();
        }
}

 

上述代码表明：静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。

④匿名内部类：当程序中使用匿名内部类时，在定义匿名内部类的地方往往直接创建该类的一个对象。

new ParentName（）{
...// 内部类的定义
}

 

 

匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的： 
·只用到类的一个实例 。 
·类在定义后马上用到。 
·类非常小（SUN推荐是在4行代码以下） 
·给类命名并不会导致你的代码更容易被理解。 
在使用匿名内部类时，要记住以下几个原则： 
·匿名内部类不能有构造方法。 
·匿名内部类不能定义任何静态成员、静态方法。 
·匿名内部类不能是public,protected,private,static。 
·只能创建匿名内部类的一个实例。 
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。 
·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。 
目前还没有具体使用过匿名内部类，对它不是很了解，有些地方表述有偏差请指出