java基础day-02

第二章、面向对象

一、什么是面向对象

面向对象就是用人的世界观改变计算机世界观

1.1 对象

万物皆可对象

学习面向对象之前先了解什么是属性和行为？

属性：表示的是事物的特征，是静态的表现

行为：表示的是事务所具有的动作，即能做哪些动作，是动态的表现

1.2 类

具有相同属性和行为的一类事物

1.3 类与对象的关系

类是对象的模板、对象是类的实例
【举例说明】
### 1.4 类的定义

public class Person(){
/**
*类名一般采用大驼峰式命名规则
*/
}

Java中最基本的单位是类

1.5 对象实例化

//类名 对象名 =  new 类名();
//实例化对象（new对象）
//调用对象的方法和属性
Person person = new Person();
person.name = "李磊";
person.getName();//调用方法

1.6 成员变量与局部变量

• 成员变量：（全局变量）生命在类中，方法体外的变量，
  作用范围：在该类的任何地方都可以使用
• 局部变量：声明在方法体内，随着方法的调用而调用，随着方法的调用完而销毁。
  作用范围：仅在本方法体内部起作用

1.7 方法

//格式：
/*
	访问控制修饰符  返回值类型   方法名（）{
		//代码块
	}
*/
public void study(){
}

1.7.1 方法的分类

1、无返回值，无参数
2、无返回值，有参数
3、有返回值，无参数
4、有返回值，有参数
	返回值：返回到方法的调用处
public void eat(){
	System.out.println("这是吃的方法");
}
public eat(String name){
    System.out.println("这是吃饭的方法，吃"+name);
}
public int eat(String name,int money){
	System.out.println("这是吃饭的方法,吃"+name+"，花费"+money+"元");
	return money;
}
public int eat() {
	int money = 8; System.out.println("这是吃饭的方法");
	return money;
}
public static void main(String[] args) {
	Person p = new Person();
	// int money = p.eat("胡辣汤", 3);
	System.out.println(p.eat("胡辣汤", 3));
	// System.out.println(a);
	p.eat();
	/**
	* 通常情况下，有返回值：在main方法中需要写输出语句；无返回值时：在main方法中直接调		用
	*/
}

面向对象的特征

继承、封装、多态、抽象

1、封装

什么是封装

封装：就是隐藏属性、方法和实现的细节的过程
作用：隔离性、安全性

权限修饰符的权限范围

	本类	同包	子类	所有
private	✔
默认	✔	✔
protected	✔	✔	✔
public	✔	✔	✔	✔

构造器、构造方法*

概念：

方法名和类名相同的方法

特点：

没有返回值，甚至连void都没有

作用：

给成员变量赋初始值

this关键字

this:自己的，本类的

1. 修饰方法，通过this.调用本类的方法，可以放在任意位置
2. 修饰类，通过this.调用本类的方法，可以放在任意位置
3. 修饰构造方法，通过this();调用，只能放在第一行

注意事项：

创建一个类时，会默认有一个无参、隐性的构造方法。
如果一旦书写了一个显性的构造方法，那么原本隐性、无参的构造器就不存在了

2、SUN公司建议：一个封装类至少包含两个构造方法（一个无参的；另一个包含所有参数的）

super关键字

​ 父类的 超类的

1. 修饰属性 ，在子类中 调用父类属性 ，放在任意行 都行
2. 修饰方法 ，在子类中 调用父类方法 ，放在任意行 都行
3. 修饰构造器，在子类中， 调用父类 构造器必须放在 第一行

return关键字

一种是返回参数所用的关键字，假如一个有返回值的方法执行完了之后需要返回一个参数

return 作用

​ 返回方法调用出

public string functionTest(){
	String a = "abc";
	return a;
}

​ 结束程序语句

for (int i = 0; i < 6; i++) {
            if (i == 3) {
                return;
            } else {
                System.out.println(i);
            }
        }

static关键字

​ 静态的，只要写上了static关键字就表示已经编译完成

1. ​ static修饰变量：静态变量

   • 既可以通过对象名.成员变量名

   • 也可以直接通过类名.成员变量名

2. ​ static修饰方法：静态方法

public class case1 {
    static int a = 10;
    static void eat(){
        System.out.println("吃");
    }

    public static void main(String[] args) {
        System.out.println(a);
        case1.eat();
    }
}

3. ​ static修饰代码块：静态代码块

• 静态代码块仅被执行一次，并且在类加载时就开始执行，优先于类中的方法。

public class case1 {
    static {
        System.out.println("124");
    }

    public static void main(String[] args) {
        //输出结果124
    }
}

2.1.8 方法的重写（override）*

​ 方法签名 方法名 +参数 列表 [参数 类型 顺序 个数] 相同

​ 子类的权限修饰符只能比父类大，不能比父类小。比如说父类是private，则子类重写给的时候无所谓，如果父类是public，则子类只能是public。子类抛出的异常只能比父类小。

2.1.9 方法的重载 （overload）*

​ 方法名相同，参数列表（参数的类型，个数，顺序）不同的方法，不能通过改变返回值类型来实现重载（如果参数列表相同的情况下）

public void eat() {
	String name = "干拌面";
	System.out.println("chifan,吃"+name);
}
public void eat(int money) {
	String name = "干拌面";
	System.out.println("chifan,吃"+name);
}
public void eat(String name) {
	System.out.println("吃饭的方法，吃了"+name);
}
public void eat(String name,int money) {
	System.out.println("吃饭的方法，吃了"+name);
}
public void eat(int money,String name) {
}

---

封装的最终表现形式：共有方法，私有变量

向上转型：由子类对象实例化父类对象

Father f1 = new Son();   // 这就叫 upcasting （向上转型)
// 现在 f1 引用指向一个Son对象  这也叫创建子类声明父类

向下转型：由父类对象实例化子类对象

Son s1 = (Son)f1;   // 这就叫 downcasting (向下转型)
// 现在f1 还是指向 Son对象

静态变量和成员变量的区别

​ ·成员变量 ：是属于对象的，必须要通过实例化对象后，通过 对象名.属性名 来调用，成员变量是某个对象私有的。

---

​ ·静态变量 ：是属于类的，所以又称为类变量，可以不用通过对象来引用，可以直接通过 类名.属性名 来调用 类变量是属于对象共有的。

public class Demo{
    private int age;
    static int age1;
    
    public static void main(String[] args){
        Demo.age1 = 10; // 类变量，通过类名直接调用
        Demo d = new Demo();
        d.age = 20; // 成员变量，只能通过对象来调用
    }
}

2. 继承

概念

在一个类的及基础上生成一个新类的过程，原来的类叫做超类或者父类，新产生的类叫做（派生类）

关键字：extends

public class Father {
	String name;
	int age;
}
public class Son extends Father{
    
}
public class Demo {
	public static void main(String[] args) {
		Son s = new Son();
		s.name = "小明";
		System.out.println(s.name);
	}
}

继承最常用的特点*

继承的特点主要有以下：

1. 子类可以继承父类非私有的变量和属性方法
2. 子类可以扩展自己的属性和方法
3. 构造器不能继承，只能重写
4. 子类可以重写父类的方法
5. 创建子类，声明父类
   • 声明什么类型，就能调用什么类型的属性的方法
   • 创建什么类型，就能把调用该类型属性和方法
   • 创建什么类型，就能强制转化为该类型

继承的写法

​ 1、 先写子类 ，抽取共性 ，作为父类，子类继承父类 (适合思路不 清晰 )
​ 2、 先写父类，再写子类 ，子类继承父类 。 适合熟练掌握知识点

3. 抽象

抽象方法

概念：

• 被abstract修饰的方法
• 没有方法体 { }
• 抽象方法是用来被子类重写

抽象类

特点：

• 由abstract修饰的类
• 不能实例化自己，即不能new自己

抽象类和抽象方法的关系

• 抽象方法所在的类一定是抽象类，但是抽象类中不一定有抽象方法

注意

如果一个子类继承了抽象父类，但是未全部重写父类中的抽象方法，那么此子类必须是抽象类。

4. 接口

你定规范，我去实现

一个类中所有方法都是抽象的，那么该类就是一个特殊的抽象类（接口）

Interface关键字

没有方法体，其里面的所有抽象方法都可以省略public abstract

接口需要实现（implements）

注意

接口满足了部分的子类的需求，可以多实现，没有先后顺序

如果一个类有继承、有实现，一定先继承，后实现

接口的特点

​**不能实例化自己，只能实例化实现子类**

接口与类，接口与接口，类与类关系

a) 类与接口：

• ​ 实现关系，既可以单实现，也可以多实现，
• ​ 并且还可以在一个类中继承一个类，然后在但实现和多实现

b) 类与类：

• 继承关系，只能单继承

c) 接口与接口：

• 继承关系，既可以单继承，也可以多继承

接口与抽象类的关系

相同点：
1、都不能被实例化。
2、接口的实现类和抽象类的子类只有全部实现了接口或者抽象类中的方法后才可以被实例化。

---

不同点：
1、接口只能定义抽象方法不能实现方法，抽象类既可以定义抽象方法，也可以实现方法。
2、单继承，多实现。接口可以实现多个，只能继承一个抽象类。
3、接口强调的是功能，抽象类强调的是所属关系。
4、接口中的所有成员变量 为public static final， 静态不可修改，当然必须初始化。接口中的所有方法都是public abstract 公开抽象的。而且不能有构造方法。抽象类就比较自由了，和普通的类差不多，可以有抽象方法也可以没有，可以有正常的方法，也可以没有。

5. 多态

多态的概念

​ 一个行为具有不同的表现形式（行为——方法；表现形式不同——重载和重写）
多态的实现机制：重写和重载

//同种事务，不同表现形态
public class Animal{
    String name;
    int age;
    
    public void eat(){
        System.out.println("父类中的吃饭");
    }
}

public class Dog extends Animal{
    @Override
    public void eat(){
	System.out.println("用舌头舔着一下一下吃");
    }
}

public class Bird extends Animal{
    @Override
    public void eat(){
     System.out.println("用舌头舔着一下一下吃");
    }
}

public class Demo{
    public static void main(String args[]){
        //Animal animal=  new Dog();
        Animal a = new Bird();
        a.eat();
        /**
        instanceof :对象引用运算符：判断某个对象是否属于相应的个类
        */
        if(a instanceof animal){
            a.eat();
        }else if(a instanceof Bird){
            a.eat();
        }
    }
}

多态性就是对象多种表现形式的体现

多态的优点

• ​ 消除类型之间的耦合关系
• ​ 可扩展性
• ​ 接口性
• ​ 灵活性
• ​ 简化性