Java（重点）知识总结*精心*期末复习*第三、四章

十三、封装

      public void SetName(String n)

{

name=n;

}

public void SetAge(int a)

{

if(a<0||a>200)

{

System.out.println("年龄错误！");

}

else 

age=a;

}

public String Getname()

{

return name;

}

public int Getage()

{

return age;

}

   

1. SetName();
2. SetAge();

String s=Getname();

Int i=Getage();

十四、继承

1. 只支持单继承，但是可以多层继承。
2. 继承父类只能使用父类公共的成员。
3. 继承的好处与弊端：

  好处：提高了代码的复用性

  弊端：类和类之间的耦合性太强

1. 子类重写父类对象：

  方法名、参数列表、返回值类型相同

  不能使用比父类中更严格的访问权限

@Override检查该方法是否是重写的方法

1. super关键字：

 可以访问父类的成员

Super.method();

public Mammal(String name, String species, int nums, String colour, int weight, String sex, String temperature) {

this.name = name;

this.species = species;

this.nums = nums;

this.colour = colour;

this.weight = weight;

this.sex = sex;

this.temperature = temperature;

}

public whale(String name, String species, int nums, String colour, int weight, String sex, String temperature) {

super(name, species,nums,colour,weight,sex,temperature);

}

whale w=new whale("鲸鱼","哺乳动物",2021,"蓝色",2,"雄性","冷血");

System.out.println(w);

十五、抽象类、接口、多态

1. 抽象类不能直接创建对象使用！！！！

2.接口定义：

Public interface 接口名{

//常量

//抽象方法

//默认方法

//静态方法

}

3.接口中不能有构造方法！！！！

接口不能直接创建对象使用

4.接口与类之间的关系：

Implements

而且可以多实现

5.接口和接口之间的关系：

 Extends

而且可以多实现

1. 多态：

 成员变量：编译看父类，运行看父类

 成员方法：编译看父类，运行看子类

1. 多态的转型：

向下转型：由父类引用转换成一个对应的真实的子类对象

格式：目标对象类型 对象名=（目标对象类型）被转换的引用

Animal a=new dog();

Dog d=(dog)a;

D.lookHome();

向上转型

1. 关键字instanceof

 用于判断左边的引用是否是右边的对象类型

If(a instanceof dog){};

十六、内部类：

1. 成员内部类：（类中类！！！！）

 创建内部类对象的格式：

 外部类名.内部类名 对象名=new 外部类对象（）.内部类对象（）;

Outer.Inner oi=new Outer().Inner();

1. 局部内部类（类中方法中的类！！！！）

 public class Outer {

int outer = 10;

public void outerMethod() {

System.out.println("Outer.outerMethod()");

}

public void function() {

class inner {

int inner = 20;

public void innerMethod() {

System.out.println("Outer.function().inner.innerMethod()");

System.out.println(outer);

outerMethod();

}

}

inner i = new inner();

System.out.println(i.inner);

i.innerMethod();

}

}

public class demo {

public static void main(String[] args) {

Outer outer=new Outer();

outer.function();

}

}

1. 静态内部类：

 Outer.inner oi=new outer.inner();

1. 匿名内部类：

 前提：必须是类或者接口

 格式：new 类名/接口名（）{

重写抽象方法

}

方法一：new Outer() {

@Override

public void eat() {

System.out.println("demo.main(...).new Outer() {...}.eat()");

}

}.eat();

方法二：Outer o= new Outer() {

@Override

public void eat() {

System.out.println("demo.main(...).new Outer() {...}.eat()");

}

};

o.eat();

十七、函数式接口：

 @functionalinterface

只能有一个抽象方法

Method1(10, 20, (num1, num2) -> {

return num1 + num2;

});

Method(() -> {

System.out.println("我是一个lambda表达式");

});

}

public static void Method(InterA a) {

a.eat();

}

public static void Method1(int num1, int num2, InterB b) {

int b1 = b.sum(num1, num2);

System.out.println(b1);

}

lambda表达式的省略规则：

1. 如果方法中只有一个参数，那么数据类型和小括号都可以省略。
2. 如果方法中有多个参数，那么数据类型可以省略。
3. 如果大括号中只有一行代码，那么大括号、return、分号都可以省略（三者必须一起省略）

方法引用与构造器引用：

1. 静态方法引用格式：方法中（类名::静态方法名称）

Method1(-20,Math::abs);

public static void Method1(int num,Calcable c) {

System.out.println(c.cal(num));

}

1. 对象名的引用：方法（对象名::方法名）

 Method1("abc", su::printUpperCase);

public static void Method1(String s,printable p) {

p.print(s);

}

1. 构造方法引用格式：方法（类名::new）

  Method1("张三", Persion::new);

public static void Method1(String name,PersionBuild pb) {

Persion p=pb.buildPersion(name);

System.out.println(p);

}

1. 类名引用普通方法：方法（类名::方法名）

 public static void main(String[] args) {

Method(new StringUtils(), "abc", StringUtils::printUpperCase);

}

public static void Method(StringUtils su,String s,printable pb) {

pb.print(su,s);

}

• 异常：

 1.对异常进行捕获和处理：try-catch-finally

 try {

int num1=2;

int num2=0;

int num=num1/num2;

System.out.println(num);

}catch(ArithmeticException a) {

a.printStackTrace();

}

finally {

System.out.println("释放了系统资源");

}

System.out.println("这是我的后续代码");

1. throws关键字：

 用来在方法的声明上去声明抛出异常，多个异常类名中间用逗号隔开。

public static void main(String[] args) throws Exception {

Method(6, 0);

}

public static void Method(int num1,int num2) throws Exception{

System.out.println(num1/num2);

}

1. throw关键字：

 public static void Method(int age) throws Exception {

if (age < 0 || age > 200)

throw new Exception("年龄不在正确的范围");

else

System.out.println("这个人的年龄是" + age);

}

1. 垃圾回收：

1. .system.gc();
2. .Runtime.getRuntime.gc();

1. JAVA常用类：

1. .字符串如何初始化

 最简单的方式：String 变量名=字符串；

通过构造方法进行初始化：

 String();                   创建一个空的字符串对象

 String（String str）;      根据传入的字符串来创建一个字符串对象

 String（char[] arr ）;      根据传入的字符数组来创建一个字符串对象

String（byte[] arr）;        根据传入的字节数组来创建一个字符串对象