Java面向对象2

# Java面向对象2

## 封装

该露的露，该藏的藏

- 我们的程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

封装（隐藏的数据）

- 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

属性私有，get/set。注意：封装一般是对于属性封装，很少对于方法。

```java

/*

封装的意义

1.提高程序的安全性，保护数据

2.隐藏代码的实现细节

3.统一接口

4.系统可维护性增加了

*/

//类 private私有的和public公共的相对,封装的核心：private私有

public class Student {

//属性私有，添加private修饰符

private String name;//名字

private int id;//学号

private char sex;//性别

private int age;//年龄

//提供一些可以操作属性的方法

//提供一些public的gat、set方法

//get 获得这个数据

public String getName(){

return this.name;

}

//set 给这个数据设置值

public void setName(String name){

this.name=name;

}

//alt+insert快捷键生成get/set

public int getId() {

return id;

}

public void setId(int id) {

this.id = id;

}

public char getSex() {

return sex;

}

public void setSex(char sex) {

this.sex = sex;

}

public int getAge() {

return age;

}

public void setAge(int age) {

if(age<120&&age>0){

this.age = age;

}else {

this.age=3;

}

}

}

```

```java

public class Application {

public static void main(String[] args) {

Student s1=new Student();

s1.setName("snow");

System.out.println(s1.getName());

s1.setAge(999);//年龄999岁是不合法

System.out.println(s1.getAge());

}

}

```

## 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

extends的意思是"扩展"，子类是父类的扩展。

Java中类只有单继承，没有多继承。一个儿子只能有一个爸爸，一个爸爸可以用多个儿子。

继承是类和类之间的一种关系。除此之外类和类之间的关系还有依赖、组合、聚合等。

继承关系的两个类，一个为子类(派生类)，一个为父类(基类)。子类继承父类，使用关键字extends来表示。

子类和父类之间，从意义上讲应该具有”is a“的关系。

```java

public class Person {

private int money=10_0000_0000;

public void say() {

System.out.println("你好");

}

public int getMoney() {

return money;

}

public void setMoney(int money) {

this.money = money;

}

}

```

```java

public class Student extends Person{

//Ctrl+H 查看继承关系

}

```

四种修饰符的作用域：

1. public 表明该成员变量或方法对所有类或对象都是可见的，所有类或对象都可以直接访问。

2. protected 表明成员变量或方法对该类自身与它在同一个包中的其他类，在同一包和其他包中的该类的子类都可见。

3. default 表明该成员变量或方法只有自己和与其位于同一包内的类可见。若父类与子类位于同一包内，则子类对父类default成员变量或方法都有访问权限；若父类与子类位于不同的package内，则没有访问权限。

4. private 表明该成员变量或方法是私有的，只有当前类对其具有访问权限，除此之外的其他类或者对象都没有访问权限。

### object类

在Java中，所有的类都直接或间接继承object类

### super

super用来调用父类的属性和方法。

```java

public class Person {

protected String name="snow";

public void print(){

System.out.println("Person");

}

}

```

```java

public class Student extends Person{

//Ctrl+H 查看继承关系

private String name="雪乡";

public void print(){

System.out.println("Student");

}

public void test1(){

print();

this.print();

super.print();

}

public void test(String name){

System.out.println(name);

System.out.println(this.name);

System.out.println(super.name);

}

}

```

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个

2. super必须只能出现在子类的方法或者构造方法类

3. super和this不能同时调用构造方法！因为构造方法必须在第一个。

```java

public class Person {

public Person() {

System.out.println("Person无参构造器执行了");

}

}

```

```java

public class Student extends Person{

//隐藏代码：调用了父类构造器

public Student() {

super();//调用父类构造器，必须要在子类构造器的第一行

System.out.println("Student无参构造器执行了");

}

}

```

super 和 this区别：

代表对象不同：

​

​

前提：

​

​

构造方法：

​

​

### 方法重写

重写的前提：

重写需要有继承关系，是子类重写父类的方法！重写都是重写类的方法和属性无关。

注意事项：

1. 方法名必须相同

2. 参数列表必须相同

3. 在非静态方法中，子类可以重写父类的方法。

4. 修饰符：范围可以扩大但不能缩小，比如父类方法修饰符是 protected，子类重写的方法修饰符可以是protected也可以是public，但是不能是作用域小的修饰符。

5. 抛出的异常：范围可以被缩小，但不能扩大。比如父类方法的异常是Exception,那子类重写的方法异常就可以是ClassNotFoundException。

重写，子类的方法和父类的方法必须一致，方法不同。

子类和父类的方法是静态的情况：

```java

public class B {

public static void test(){

System.out.println("B=>test()");

}

}

```

```java

public class A extends B{

public static void test(){

System.out.println("A=>test()");

}

}

```

```java

public class Application {

public static void main(String[] args) {

//方法的调用只和赋值符左边，定义的数据类型有关。

A a =new A();

a.test();//显示A=>test()

//父类的引用指向了子类

B b=new A();

b.test();//显示B=>test()

}

}

```

子类和父类的方法非静态：

```java

public class B {

public void test(){

System.out.println("B=>test()");

}

}

```

```java

public class A extends B{

//Override 重写

//快捷键Ait+Insert,选择Override重写。

@Override//注解：有功能的注释。

public void test() {

System.out.println("A=>test()");

}

}

```

```java

public class Application {

//静态方法和非静态的方法区别很大！方法重写只在非静态方法中可以实现。

public static void main(String[] args) {

A a =new A();

a.test();//显示A=>test()

B b=new A();//在非静态方法中，子类可以重写父类的方法。

b.test();//显示A=>test()

}

}

```

为什么需要重写：

- 父类的功能子类不一定需要，或者不一定满足。

## 多态

动态编译：类型，可扩展性。

即同一方法可以根据发送对象的不同而采用多种不同的行为方式。

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。

### 多态存在的条件

- 有继承关系

- 子类重写父类方法

- 父类引用指向子类对象 Father f1=new Son(）

```java

public class Person {

public void run(){

System.out.println("run");

}

```

```java

public class Student extends Person{

public void run(){

System.out.println("son");

}

public void eat(){

System.out.println("est");

}

```

```java

public class Application {

public static void main(String[] args) {

//一个对象的实际类型是确定的

//new Student();

//new Person();

//可以指向的引用类型就不确定了：父类的引用指向子类

Student s1=new Student();

//Person 父类型，可以指向子类，但是不能调用子类独有的方法。

Person s2 = new Student();

Object s3 =new Student()

//子类重写了父类的方法，执行子类的方法。

s2.run();//显示son

//Student能调用的方法都是自己的或者继承父类的！

s1.run();//显示son

s1.eat();//显示eat

//对象能执行那些方法，主要看对象左边的类型，和右边关系不大，Peraon类没有这个eat()的方法。

s2.eat();//报错

}

}

```

注意：

1. 多态是方法的多态，属性没有多态。

2. 父类和子类，两个类是有继承关系的，如没有继承关系则会出现类型转换异常的错误！ClassCastException!

### instanceof

instanceof 类型转换，引用类型转换，判断一个对象是什么类型~

instanceof 可以判断两个类是否存在继承关系。

```java

public class Person {

}

```

```java

public class Teacher extends Person {

}

```

```java

public class Application {

public static void main(String[] args) {

//Object>Person>Teacher

//Object>Person>Student

Object object = new Student();

//System.out.println(X instanceof Y);//能不能编译通过，如果编译可以通过说明两个类有关系。

System.out.println(object instanceof Student);//显示结果turn

System.out.println(object instanceof Person);//显示结果turn

System.out.println(object instanceof Object);//显示结果turn

System.out.println(object instanceof Teacher);//显示结果false

System.out.println(object instanceof String);//显示结果false

System.out.println("=========");

Person person = new Student();

System.out.println(person instanceof Student);//显示结果turn

System.out.println(person instanceof Person);//显示结果turn

System.out.println(person instanceof Object);//显示结果turn

System.out.println(person instanceof Teacher);//显示结果false

//System.out.println(person instanceof String);//编译报错

System.out.println("=========");

Student student = new Student();

System.out.println(student instanceof Student);//显示结果turn

System.out.println(student instanceof Person);//显示结果turn

System.out.println(student instanceof Object);//显示结果turn

//System.out.println(student instanceof Teacher);//编译报错

//System.out.println(student instanceof String);//编译报错

}

}

```

#### 类型转换

```java

public class Person {

}

```

```java

public class Teacher extends Person {

}

```

```java

public class Application {

public static void main(String[] args) {

//类型之前转换：父类型是高的一方 子类型是低的一方

//类型从高到低是自动转换，从低到高需要强制转换。

Person obj = new Student();

//obj将这个对象转换为Student类型，我们就可以使用Student类型的方法了。

Student student=(Student) obj;

student.go();//直接可以写成（（Student）obj）.go();

Person person = student;

//父类强制转换为子类，可能丢失自己本来的一些方法！

//person.go()//报错没有这个方法。

}

}

```