JAVA基础学习笔记_面向对象进阶+集合

医院医疗系统(his系统)也是用的java

集合

集合(容器)长度可变,存引用,存基本要用包装类
ArrayList<String> list=new ArrayList<String>()
<>内为泛型
添加元素
list.add("aaa");
删除元素
list.remove("aaa");
修改
list.set("1,"ddd");
查询
String str=list.get(o);
获取长度
list.size();
类名方法名都是地址
集合添加其实是地址值
java中因为没有指针的显示利用,所以变量名都是地址,Student u1=u2,u1和u2是同一地址的数据
更改u1,u2也会变
只有new出来的才是不同的对象
C++不同,因为可以利用指针,所以当用Student u1=u2时,是copy对象,更改u1,u2不会变

面向对象进阶

static
在类中的变量用static修饰,其所有对象都共享一个变量值
静态区存放静态变量
javabean类,用来描述事物
测试类,用来检查其他类书写正确
工具类,不是用来描述一类事物的,而是做一些事情
注:
静态方法只能访问静态
非静态能访问所有
静态方法不能访问this关键字
String[] args以前用于接收键盘录入数据,现在没用,相当于C中的接受命令行参数

extends继承

解决子类的需求
类和类之间存在相同的内容,子类是父类的一种
C++允许多继承
但java只能单继承
默认/所有类的父类object
继承,从父类:
构造方法 private(n) public(n)
成员变量 private(y) public(y)
成员方法 private(n) public(y)
继承子类有虚方法表,防止多层继承效率慢,直接找到那个间接父类
虚方法表只记录虚方法,
成员变量的就近继承原则 name
this.name 从此类中的成员变量往上找name
super.name 从父类中的成员变量往上找name
@Override方法的重写,当父类方法不能满足子类需求,##这里和重载不同
重写虚方法表内容,只有虚方法中的方法才能被重写
子类的方法重写形式尽量和父类一致(返回值类型\形参\方法名)
super();
子类访问父类的无参构造,因为要继承父类中的定义,不写super(),系统默认添加super
继承有参构造super(name,id)
本类访问其他构造this(11,张三,23)

class Parent {
    Parent(String name) {
        System.out.println("Parent constructor called: " + name);
    }
    String name = "Parent Name";
    void greet() {
        System.out.println("Hello from Parent");
    }
}

class Child extends Parent {
    Child(String name) {
        super(name); // 调用父类构造函数
        System.out.println("Child constructor called: " + name);
    }
    String name = "Child Name";
    void greet() {
        System.out.println("Hello from Child");
    }

    void displayGreetings() {
        greet(); // 调用子类的方法
        super.greet(); // 调用父类的方法
    }

    void displayNames() {
        System.out.println("Child's name: " + name); // 子类的name
        System.out.println("Parent's name: " + super.name); // 父类的name
    }
}

多态

当一个方法的参数是父类时,可以传递接口的所有子类的对象,避免重重复代码出现
继承补充封装,多态补充继承
解决兄弟之间的矛盾
对象的多种形态
父类引用指向子类对象
person fu=new Student();
成员变量对应父类的成员变量
成员方法对应子类的成员方法
编译时都对应父类,父类中没有就报错
Student fu=new Student();符合就近原则
person fu=new Student();先找父类
所有类的父类object
//多态的弊端就是不能调用子类中特有的方法,但是可以强转,如,dog d=(dog)a;
java14新特性:
a instanceof Dog d //判断数据类型,并强转成Dog,用d指针指向

Queue<TreeNode> queue = new LinkedList<>();
//只能用Queue接口中的方法,更具通用性,如果LinkedList中有重写Queue中的方法
//还是使用Queue中的方法
LinkedList<TreeNode> queue = new LinkedList<>();
//LinkedList中的方法都可以使用,如果LinkedList中有重写其接口中的方法
//就近使用LinkedList中的方法

补充

包名+类名=全类名

import com.itheima.test.Person //域名书写规范,公司域名+包作用
同一个包内的类不需要导包
java.lang包不需要导包

final//最终的不可改变的类

方法,不能被重写
类,不能有子类
变量,不能再被赋值,即常量(规范,变量名全大写)(C++宏定义,const)
基本数据类型,变量名=数据
引用数据类型,变量名=地址

权限修饰符

private 只能自己用,奴隶社会自己享受
默认不写 只能在本包用,封建社会家庭享受
protected 受保护的,其他包中的子类也可以用,改良资本主义社会,私生子受法律保护,私生子也可以享受资源
public 所有都可用,共产主义天下大同
默认规则
变量一般私有
方法一般公开

代码块{}

局部代码块,作用域,代码块运行完就释放空间,(已被淘汰,不缺那点内存)
构造代码块,使多个构造函数中重复的代码只用写一次
静态代码块,static{},随类加载,自动触发执行,只执行一次,不管调用这个类多少次,用来添加一些初始化信息

抽象类

abstract
仔细去理解多态是在干嘛,自己总是将抽象类的作用安在多态上
相对于重写,可防止子类忘记填补这个方法的使用编写,但是也要加上@Override
抽象类不能实例化
抽象类的子类要么重写抽象类的所有抽象方法,要么也是抽象类
因为公司里团队合作,所以抽象类是规范代码,规范所有人写代码的形式,

接口

interface
类连接接口
public class dog extends animals implements inter1,inter2{};
一部分类有的方法,但另一些类没有,需要定义接口同一规则标准
这些类不一定同属一个父类
接口就是一种规则
接口中的成员变量只能是常量,默认修饰 public static final,
反正子类中的共有属性\变量只定义在父类中,不会在接口中用
接口没有构造方法
接口与接口之间也可以继承,而且可以多继承
多学三招
1.jdk8之后新增方法
可以定义有方法体的方法,防止接口中新增方法,但却没在继承类中写实现代码
jdk9之后新增方法
可以定义私有方法,为接口中消除重复代码
2.接口的第二个用法,
接口类型 j=new 实现类对象();
即,当一个方法的参数是接口时,可以传递接口的所有实现类的对象,这种方式称之为接口多态
3.配适器设计模式
设计模式(design pattern),代码设计经验的总结,就是各种套路
当接口中抽象方法过多时,只需要用一部分使用,
编写一个中间类,xxxAdapter,空实现所有
实现类中重写需要的方法
中间的配适器类用abstract修饰

内部类

在一个类里面再定义一个类,内部类是外部类的一部分,比如引擎与车
类的五大成员:
属性\方法\构造方法\代码块\内部类
(迭代器被设计为Arraylist的内部类)
内部类分类
1)成员内部类
Outer.this.a获得外部类的属性变量值
2)静态~,定义在方法内的内部类
3)局部~
4)匿名~(**重点),隐藏了名字的内部类,但其实是建了一个对象

new animal(){
	public void eat(){
		system.out,println("狗吃骨头");
	}
}

是继承了animal这个父类或者接口
某个子类只要用一次,还需要单独定义一个类太麻烦,所以可以用到匿名内部类
就是可以将定义和调用两件事一块做,更方便
不是真的没有名字,只是被隐藏起来了
所以跟内部有什么关系?即可单独出现,也可以出现局部和成员位置