Javase基础3

第七章 面向对象1

1.类和对象

1.匿名对象的使用

①格式：只有等号右边的new对象部分,没有等号左边的部分

new 对象名().成员名 -> 成员变量,成员方法

②

public class Person { String name; public void eat(){ System.out.println("人吃饭"); } } public class Demo01 { public static void main(String[] args) { //匿名对象方式 new Person().eat(); new Person().name = "小白"; System.out.println(new Person().name); } }

2.成员变量与局部变量的区别

1.成员变量：在类中方法外，有默认值，作用于整个类，内存位置在堆中，生命周期随着对象的创建而创建,随着对象的消失而消失。

2.局部变量：方法内或者参数位置，没有默认值,需要初始化之后才能使用，只作用于自己方法内部，内存位置在栈中，生命周期随着方法的运行而创建,随着方法运行完毕而消失。

3.练习

1.定义一个类MyDate,代表生日,类中定义三个属性,分别为 year month day,并为三个属性赋值

public class MyDate { int year; int month; int day; }

2.定义一个公民类Citizen,类中定义三个属性,分别为cardId(String),name(String),MyDate(MyDate),并为三个属性赋值。

public class Citizen { String cardId; String name; MyDate birthday; }

public class test01 { public static void main(String[] args) { MyDate myDate=new MyDate(); myDate.year=2025; myDate.month=3; myDate.day=30; System.out.println(myDate.year); System.out.println(myDate.month); System.out.println(myDate.day); Citizen ciz=new Citizen(); ciz.name="王五"; ciz.cardId="01"; ciz.MyDate=new MyDate(); MyDate myDate1=ciz.MyDate; myDate1.year=2026; myDate1.month=6; myDate1.day=26; System.out.println(ciz.name); System.out.println(ciz.cardId); System.out.println(myDate1.year+","+myDate1.month+","+myDate1.day); } }

4.封装的介绍

1.概述：不让外界直接使用该类的方法和属性，对外提供一套公共接口，让外界通过这个接口间接使用方法和属性。

2.代表性关键字：private关键字（私有化）

范围：只能本类使用私有成员,别的类不能直接调用

3.为私有属性提供公共的接口的方法是：getter和setter方法

作用是分别为私有属性赋值和获取值

快捷键是：alt＋insert，点getter和setter方法

public class Student { String name; int age; static String classRoom; public Student() { } public Student(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public static String getClassRoom() { return classRoom; } public static void setClassRoom(String classRoom) { Student.classRoom = classRoom; } }

public class test04 { public static void main(String[] args) { Student.classRoom="教室"; Student stu1=new Student(); stu1.setName("金大喜"); stu1.setAge(35); System.out.println(stu1.getName()+","+stu1.getAge()+"岁,教室为:"+Student.classRoom); Student stu2=new Student(); stu2.setName("王安棍"); stu2.setAge(28); System.out.println(stu2.getName()+","+stu2.getAge()+"岁,教室为:"+Student.classRoom); } }

一个类中如果有私有属性的话，那么getter和setter方法基本就是配套使用的

5.this的介绍

1.概述：哪个对象调用的this所在的那个方法,this就代表哪个对象（this后面的一点故事成员变量）

2.注意：局部变量和成员变量重名,要遵循"就近原则",先访问局部的

public class Person { private String name; private int age; public void eat(){ System.out.println(name+"说人要吃饭呢"); } public Person(){ } public Person(String name,int age){ this.name=name; this.age=age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age<0){ age=0; }else { this.age = age; } } }

public class test03 { public static void main(String[] args) { Person person=new Person(); System.out.println(person); System.out.println(person.getName()+".."+person.getAge()); person.setName("小王"); person.setAge(18); System.out.println(person.getName()); System.out.println(person.getAge()); Person person1=new Person("小王",18); System.out.println(person1); System.out.println(person1.getName()+".."+person1.getAge()); } }

6.构造方法（构造器）

1.无参构造

public 类名(){ }

作用：new对象使用

Person p1 = new Person(); //括号中没有参数

2.有参构造

public Person(形参){ 为属性赋值 }

作用：new对象使用

Person p2 = new Person("小白", 18); //括号中有参数

7.Static静态关键字

//修饰方法 权限修饰符 static 返回值类型 方法名(形参){ 方法体 return 结果 } //修饰变量 权限修饰符 static 数据类型 变量名

1.特点：

①静态成员属于类成员，非静态成员属于对象成员

②随着类的加载而加载

③优先于对象存在

④有static的属性或者方法，可以直接调用（类名直接调用）

public class Student { String name; int age; static String classRoom; }

public class Test01 { public static void main(String[] args) { //为静态成员赋值 Student.classRoom = "教室"; //创建对象 Student s1 = new Student(); s1.name = "小白"; s1.age = 18; System.out.println(s1.name+"..."+s1.age+"..."+Student.classRoom);

2.静态成员的访问特点

①只要是调用静态成员,不管在不在同一个类中,能直接调用就直接调用,不能直接调用就类名调用

②只要是调用非静态成员,不管在不在同一个类中,能直接调用就直接调用,不能直接调用就new对象调用

3.如果将所有成员都定义成静态成员,那么静态成员不管是有用的,没用的,都会随着类的加载而加载,会占用内存。定义工具类的时候,工具类中的成员都是静态成员。工具类中，要求构造私有化，成员都是静态。

第八章 面向对象2

1.JavaBean的作用

1.javabean和表的对应关系

2.对象数组

public class Person { private String name; private int age; public Person() { } public Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }

public class Test01 { public static void main(String[] args) { Person[] arr1 = new Person[2]; Person p1 = new Person("张三", 19); Person p2 = new Person("李四", 21); arr1[0] = p1; arr1[1] = p2; //遍历 for (int i = 0; i < arr.length; i++) { System.out.println(arr1[i].getName()+"..."+arr1[i].getAge()); } } }

3.继承

1.定义:父类和子类的关系就是继承，将父类中的方法继承给子类使用，如果子类不适合父类的方法，那就需要重写父类的方法，如果子类适合父类的方法，那就可以直接调用。

子类 extends 父类{}

2.注意：

①构造方法不能继承，不能重写

②静态方法能继承，但是不能被重写

③子类可以继承父类的私有和非私有成员，但是子类不能直接使用父类的私有成员

由于子类与父类的方法相同，我们就不写子类的方法了，直接继承父类的方法去使用就可以了

public class Employee { String name; Integer age; public void work(){ System.out.println("员工正在工作"); } }

public class Teacher extends Employee{ }

public class Teacher2 extends Employee{ }

public class test02 { public static void main(String[] args) { Teacher t1=new Teacher(); t1.work(); t1.name="小天"; t1.age=18; System.out.println(t1.name); System.out.println(t1.age); Teacher2 t2=new Teacher2(); t2.work(); t2.name="小来"; t2.age=19; System.out.println(t2.name); System.out.println(t2.age); } }

3.继承中成员变量和成员方法的访问特点

1.①成员变量，子类父类成员变量不重名

public class Zi extends Fu{ int numZi = 10; }

public class Fu { int numFu = 1000; }

public class Test01 { public static void main(String[] args) { Zi zi = new Zi(); System.out.println(zi.numFu);//1000，子类对象可以直接访问继承来的父类变量 System.out.println(zi.numZi);//10，子类访问自己的变量 Fu fu = new Fu(); System.out.println(fu.numFu);//1000，父类访问自己的变量 } }

②成员变量，子类父类成员变量重名

public class Fu { int num = 1000; }

public class Zi extends Fu{ int num = 10000; }

public class Test01 { public static void main(String[] args) { Zi zi = new Zi(); System.out.println(zi.num);//10000 Fu fu = new Fu(); System.out.println(fu.num);//1000 System.out.println("=================="); //多态（成员变量看等号左边） Fu fu1 = new Zi(); System.out.println(fu1.num);//1000 } }

2.成员方法

①子类和父类中的成员方法不重名

public class Fu { public void methodFu(){ System.out.println("父类方法"); } }

public class Zi extends Fu { public void methodZi(){ System.out.println("子类方法"); } }

public class Test01 { public static void main(String[] args) { Fu fu = new Fu(); fu.methodFu();//父类方法 Zi zi = new Zi(); zi.methodZi();//子类方法 zi.methodFu();//父类方法，子类对象可以直接使用继承来的父类方法 } }

②子类和父类中的成员方法重名

public class Fu { public void method(){ System.out.println("父类的方法"); } }

public class Zi extends Fu { public void method(){ System.out.println("zi类的方法"); } }

public class Test01 { public static void main(String[] args) { //多态形式new法 Fu fu1 = new Zi(); fu1.method();//子类的方法，成员方法看等号左边，如果子类没有方法，则调用父类 } }

3.重写

①证明重写的方法：再重写的方法上面写上@Override这个注解，如果没有报错，则说明该方法重写了。

②重写的注意事项：

子类方法重写父类方法，权限必须要保证>=父类权限。(public -> protected -> 默认 -> private)

方法名和参数列表都要一样

私有方法，构造方法，静态方法都不能重写

子类重写方法的返回值类型，可以是相同类型也可以是子类类型

私有方法可以继承但是不能被重写,构造方法不能被继承,也不能被重写,静态的能继承,但不能重写

4.特点：

可以单继承，不可以多继承

可以多层继承

一个父类可以有多个子类

4.this和super

①super（必须用在第一行）：父类引用，调用父类的成员变量和成员方法

调用父类的无参构造的时候-->super()

调用父类的有参构造的时候-->super(实参)

调用父类的成员变量-->在子类中写(super.成员变量名)

调用父类的成员方法-->在子类中写(super.方法名（）)

②this（必须用在第一行）：代表当前对象

调用当前对象的无参构造-->this()

调用当前对象的有参构造-->this(实参)

调用当前对象的成员变量-->this.成员变量名

调用当前对象的成员方法-->this.方法名()

5.父类中private的成员变量赋值

①set赋值

public class Employee { private String name; private int age; public Employee() { } public Employee(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }

public class Teacher extends Employee{ }

public class Test01 { public static void main(String[] args) { Teacher t1 = new Teacher(); t1.setName("张三"); t1.setAge(18); System.out.println(t1.getName()+"..."+t1.getAge()); } }

②构造方法赋值

public class Employee { private String name; private int age; public Employee() { } public Employee(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } }

public class Teacher extends Employee{ public Teacher() { } public Teacher(String name, int age) { super(name, age); } }

public class Test01 { public static void main(String[] args) { Teacher t2 = new Teacher("李四",20); System.out.println(t2.getName()+"..."+t2.getAge()); } }

第九章 面向对象3

1.抽象

1.抽象类定义：

public abstract class 类名{}

2.抽象方法定义

权限修饰符 abstract 返回值类型 方法名(形参);

3.抽象类注意：

①抽象类不能直接new对象，只能创建非抽象的子类对象

②有成员变量,构造,成员方法

③有构造方法,是供子类创建对象时,初始化父类中的属性使用的

④不一定非得有抽象方法,但是有抽象方法的类一定是抽象类

⑤抽象类的子类,必须重写父类中的所有抽象方法,除非该子类也是抽象类

public abstract class Employee { public abstract void work(); }

public class Teacher extends Employee{ @Override public void work() { System.out.println("工作"); } }

public class Test01 { public static void main(String[] args) { Teacher t1 = new Teacher(); t1.work(); } }

2.接口

1.接口定义：

public interface 接口名{}

2.实现类定义：

public class 类名 implements 接口名{}

3.代码

public interface USB { public abstract void open(); public abstract void close(); }

public class Mouse implements USB{ @Override public void open() { System.out.println("鼠标打开"); } @Override public void close() { System.out.println("鼠标关闭"); } }

public class Test { public static void main(String[] args) { Mouse mouse = new Mouse(); mouse.open(); mouse.close(); } }

4.接口中的成员

①抽象方法

修饰符 abstract 返回值类型 方法名(形参);

②默认方法

修饰符 default 返回值类型 方法名(形参){ 方法体 return 结果 }

③静态方法

修饰符 static 返回值类型 方法名(形参){ 方法体 return 结果 }

④成员变量

public static final 数据类型 变量名 = 值

⑤私有方法

修饰符 private 返回值类型 方法名(形参){ 方法体 return 结果 }

5.接口的特点：可以多继承，可以多实现类，一个子类继承一个父类的同时可以实现一个或者多个接口。

6.接口和抽象类区别

3.final关键字

1.①格式

public final class 类名{}

②特点：被final修饰的类不能被继承

2.①默认方法格式

修饰符 final 返回值类型 方法名(形参){ 方法体 return 结果 }

②特点：被final修饰的方法不能被重写，final和abstract不能同时作用在一个方法中

3.①成员变量格式：

final 数据类型 变量名 = 值

②特点：被final修饰的成员变量被定义的时候直接赋值，不能二次赋值

4.局部变量格式

final 数据类型 变量名 = 值

5.①对象

final 类名 对象名 = new 类名()

②地址值不能改变，属性值可以改变

4.权限修饰符

①private，属性，封装思想

②public，构造，便于new对象

③public，方法，便于调用