【无标题】

1. private 是用在本类之中的可以调用的;
   缺省是本类和本包里面可以调用的
   public是整个项目可以

2. 属性就是实例变量,int age; String name;
   3.默认初始化(String是null ,int是0,double是0.0) 显式初始化(int age=1) 构造器初始化 (三种初始化只调用一次)

   通过对象.属性 对象.方法 (两种可以调用多次)
   调用顺序是 前三个初始化 后两个是调用

4.使用在setxxx方法的,
this.属性(实例参数),属性是形式参数

this就是p1,p2,p3动态的,谁调用setAge()方法
{p1.setAge()就是 p1就是this}
this.age就是属性,age就是形参

this就是实例化的引用

java的继承是可以多层继承，不可以多继承（写多个extends）。

super知识点

1. new Circle() 就是意思就是运行该类里面的Circle()类的构造方法，new Circle(1,2,3)也是在运行该类的构造方法。

2. //无参构造在new无参的时候会运行。
   public Circle() {
   this.radius=1;
   }

就是子类和父类有一样的属性和方法都在一个实例里面，然后怎么调用父类里面的方法和实例。
super是在子类继承父类的时候，子类里面调用父类里面的方法使用，可以调用父类的属性和方法。
super.— 是在子类调用父类属性和方法。
继承只能继承属性和方法，不能继承构造器给子类。
只能在子类使用super(参数)，调用父类的构造方法。
super()只能在放在构造方法首行.this()也可以放在构造器方法首行的.但是二者只能放一个.this(参数)是调用构造方法重载的方法.

4.子类构造器默认会调用本类中重载的构造器要么会调用父类的无参构造器.(
感觉就是激活了子类之后就会激活父类,然后才能调用父类的方法和属性.)
如果在子类构造器的首行没有显示调用“this（形参列表），也没有显式调用“super（形参列表）”则子类此构造器默认调用“super），即用父类中空参的构造器。
由③和④得到结论：子类的任何一个构造器中，要么会调用本类中重载的构造器，要么会调用父类的构造器只能是这两种情况之一。
由得到：一个类中声明有n个构造器，最多有n-1个构造器中使用了“this彩参列表）”
则剩下的那个一定使用“super（形参列表）”

多个子父类继承的时候，先生成 根父类，然后一个一个生成下来，直到最下面的子类。然后实例化最底下的子类。

5. this是先查看本类的,super.是先查看父类的

权限修饰符：public,protected,缺省,private

修饰符	本类	本包	其他包子类	其他包非子类
private	√	×	×	×
缺省	√	√（本包子类非子类都可见）	×	×
protected	√	√（本包子类非子类都可见）	√（其他包仅限于子类中可见）	×
public	√	√	√	√

外部类：public和缺省

成员变量、成员方法等：public,protected,缺省,private

心得：缺省是在本包可以使用，出了包就不可以使用了
protected是本包可以使用，出了包就必须继承才可以使用。

7.多态

1. 多态性的应用：虚拟方法调用
   在多态的场景下，调用方法时。
   编译时，认为方法是左边声明的父类的类型的方法（即被重写的方法）
   执行式，实际执行的是子类重写父类的方法。】

在多态的场景下，调用属性时。
编译时，执行式，都看左边的类型。

2.使用的前提是: 1.有继承关系 2. 要有方法重写.一般都是适用于方法,不适合使用属性.
3.Animal animal=new Dog()
Animal animal1=new Cat();animal都可以调用cat dog的方法.

4.优点:减少冗余

缺点:1.在内存中加载了子类特有的方法和属性 , 但是不能使用子类的属性和特有方法 2.只能使用父类和子类重写的方法.

类中会默认给一个无参数构造函数,但是有生成其他之后就会覆盖掉,子类的构造器super()会寻找父类的无参数构造.

8.Object

1.java.lang.Object 是根父类，每个类都是Object作为超类。 java类都是继承Object类。

2.Object类中没有属性，有一个空参构造器，一共11个方法。

equals()\toString() 重点关注
clone()\finalize()了解
getClass() \ hasCode() \notify()\notifyall()\wait()\wait(xx)\wait(xx,yy)

clone()是复制一个对象的对空间给一个引用。
finalize()当对象回收对象时候，调用该方法

3.equals()

1.用于任何引用数据类型。
2.自定义的类（自己写的类）没有重写Object中的equals（）方法的况下，调用的是Object类中的声明的equals（），
比较两个对象的引用地址是否一样（是否指向同一个堆空间中的同一个对象）或者是比较两个对象的值。
3.对于像String，file，data和包装类等等，都重写了equals（）方法，用于比较两个对象的内容是否一样相等。
4.自定义的类中，重写的equals（）是比较两个类中的属性值是否相等。

== 是一个运算符号，基本数据类型时候比较数值，引用数据类型比较地址值。
equals() 只能用在引用数据类型上，没有重写底层是使用==,重写了就是比较引用的各个属性的值

Animal a1;
        a1.euqals();
//a1使用Animal类里面重写的的equals()方法.
//引用a1的Animal类的equals()方法

 public boolean equals(Object o){
        if(this==o)return true;
        if(o==null||getClass()!=o.getClass())return false;
        Customer customer=(Customer)o;
        return age==customer.age&&Objects.equals(name,customer.name)&&Objects.equals(acct,customer.acct);
        }

4.toString()方法

public static String valueOf(Object obj){
        return(obj==null)?"null":obj.toString();
        }

return getClass().getName()+"@"+Integer.toHexString(hashCode());

System.out.println(u1);//引用变量u1
//该语句的底层就是在调用String.valueOf(x)方法.之后调用valueof()方法.
//输出为:com.atguigu.www.ToString.User@404b9385
//类名+十六进制哈希值

2. System.out.println(u1); 打印对象引用变量时候,其实调用了toString()方法.

3. 子类使用说明:

   子类没有重写tostring方法,使用object的toStirng方法

String 、File 、Date或者包装类都重写了toString()方法.返回当前对象的实体内容.

重写后的是返回对象的数据值.

重点:equals()返回的是比较两个引用对象的属性的值是否相等.toString是拿到引用对象的属性的全部值.

static

1. 个数：静态变量有一个空间,实例变量有多少个空间就有多少个。
2. 区域: 静态变量是在堆空间内,实例变量是在堆空间对象内的空间.

静态方法,1. 类名.静态方法 或者 引用名.静态方法.

2. 静态方法内只能调用静态方法,不能调用实例方法.(与生成时机有关. )

非static修饰的方法内,可以调用类中的静态结构(属性和方法.)或者非静态结构.
static之中不能使用this.super(this,super都是需要有实例才能够调用的.)

开发之中,什么时候需要将属性声明为静态的?

多个实例共用一个属性,而且值相等.

心得:1.使用了static变量的属性,就是把属性空间放在了堆空间之中,而且他的生命周期是随着类的诞生而诞生,随着类的消失而消失,
而不是随着实例的消失而消失.所以使用后的值都放在堆空间中.

2.static 修饰的方法
可以直接使用类名调用静态方法. 例如:Arrays.sort();

单例设计模式

1.饿汉式

package com.atguigu.www.staticdemo;

//1.饿汉式
public class BankTest {
    public static void main(String[] args) {
//        Bank b1 = new Bank();
//        Bank b2 = new Bank();
        Bank b2=Bank.getInstance();
        System.out.println(b2.id);
        System.out.println(Bank.getInstance().id);
    }
}


class Bank {
    //    1.类的构造器私有化,不能够在其他类自己创建.
    private Bank() {
    }

    static int id = 1;
//    2.在类的内部创建当前类的实例.

    //    4.属性修饰为static.
    private static Bank instance = new Bank();

    //3.使用getxxx()获得实例,必须声明static的
    public static Bank getInstance() {
        return instance;
    }

    //非static方法,先创建实例后在调用get/set方法
    public void setInstance(Bank instance) {
        this.instance = instance;
    }
}

2. 懒汉式

package com.atguigu.www.staticdemo;

//2.饿汉式
public class GirlFriendTest {
    public static void main(String[] args) {
        GirlFriend g1= GirlFriend.getInstance();
        System.out.println(g1.id);
    }
}

class GirlFriend {
    int id=2;
    //
    private GirlFriend() {

    }
    private static GirlFriend instance = null;

    public static GirlFriend getInstance() {
        if (instance == null) {
            instance = new GirlFriend();
        }
        return instance;
    }


}

心得:

懒汉式是可以先节约空间,“延迟加载”,在需要的时候才加载.
饿汉式是"立即加载",随着类的加载而加载,当前实例就加载了.

控制行操作
javac demo.java
java demo

类中可以声明的结构有:属性、方法、构造器、代码块、内部类

代码块的作用

1. 用来
   2. 使用
   静态代码块: 1.随着类的加载而执行.例如Person.info,相当于在加载Person类.
   2.通常类加载只执行一次,所以静态代码块只执行一次.
   3.内部可以声明变量、调用属性或者方法,编写输出语句等操作.
   4. 静态代码块先与非静态的代码块 5.声明多个就按照先后顺序
   6.静态代码块内部只能调用静态的结构
   心得:1. 随着类的调用那就只能调用静态的属性.与调用时机有关.
   非静态代码块: 1.随着对象的创建而执行. 2.每创建当前类的一个实例,就执行一次非静态代码块.
   3.作用:内部可以声明变量、调用属性或者方法,编写输出语句等操作.
   4.声明多个就按照先后顺序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ku426pCX-1687787274611)(img.png)]

代码块:心得:从多个构造器里面提取出公共的部分.例如:一个类需要链接数据库,进行数据库链接,提前做好工作.而且不用造对象就可以运行,如果不用代码块,而是使用静态方法则是要多调用一次静态方法.