面向对象2

文章目录

• 对象与引用
• • 值传递与引用传递
  • • Java中进行方法调用中传递参数时，参数传递有两种：
    • • 1.值传递：(形参数类型是基本数据类型)：
      • 2.引用传递：(形参数类型是引用数据类型参数)：
• this关键字
• static关键字
• 代码块
• 包（package)
• 访问权限修饰符
• 面向对象特征
• • 面向对象语言的三大特征：
• 封装
• 继承
• • 重写父类方法
  • super关键字
  • Object类
• 抽象类
• • ● 抽象方法
  • ● 特点:
• 多态
• • 多态概述
  • 多态环境下对成员方法、静态成员方法、对成员变量的调用
  • 多态转型
• final关键字
• 接口
• • 接口概述

对象与引用 值传递与引用传递 Java中进行方法调用中传递参数时，参数传递有两种： 1.值传递：(形参数类型是基本数据类型)：

方法调用时，实际参数把它的值传递给对应的形式参数，形式参数只是用实际参数的值初始化自己的存储单元内容；是两个不同的存储单元，所以方法执行中形式参数值的改变不影响实际参数的值。

       
public class JibenDemo {
    public static void main(String[] args) {
        JibenDemo a = new JibenDemo();
        int b = 10;
        a.test(b);
        System.out.println(b);
    }
         
    public void test(int c){
        c = 20;//c的值发生改变不影响b

输出为：10

2.引用传递：(形参数类型是引用数据类型参数)：

也称为传地址；方法调用时，实际参数是对象，这时实际参数与形式参数指向同一个地址；在方法执行中，对形式参数的操作实际上就是对实际参数的操作，这个结果在方法结束后被保留了下来，所以方法执行中形式参数的改变将会影响实际参数。基本类型传递的是该数据值本身。引用类型传递的是对对象的引用，而不是对象本身 。

        
public class YingyongDemo {
    public static void main(String[] args) {
        YingyongDemo a = new YingyongDemo();
        Person zs = new Person("张三",'男',20);
        a.test(zs);//只是把对象地址传递给了b
        System.out.println(zs.name);
    }
    public void test(Person b){     //b和zs指向的是同一个对象
        b.name = "小乐";
    }
}

this关键字

this关键字代表当前对象；使用this关键字引用成员变量 ；使用this关键字引用成员方法；

在一个类的方法或构造方法内部，可以使用“this.成员变量名”这样的格式来引用成员变量名，常常用来区分同名的成员变量和局部变量；

public class People {
    private String country;
    public People(){

    }
    public People(String country){
        super();
        this.country = country;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }
}

static关键字

静态（类变量，和类一样只有一份），可以修饰属性、方法、代码块、内部类。

被static修饰的内容，随着类的加载而加载，优先于对象存在，被所有对象共享，可以通过类名直接调用。

静态方法不能使用非静态的成员变量，静态资源随着类先加载；非静态的随着对象的创建而加载。

非静态方法可以使用静态变量，非静态方法必须通过对象来调用，对象创建之前先加载类。

static属性

public class Chinese{ 
    String name ;//姓名（非静态属性）
    static String country;//国家（静态属性） 
 ｝

代码块

代码块：类似一个没有名字的方法；

分为：实例代码块和静态代码块；

实例代码块：在创建对象之后执行，调用构造方法之前执行，每创建一个对象，执行一次；

静态代码块：在类加载时执行，只执行一次；

public class Demo {
    String name;
    static String car = "奔驰";

    public Demo(){
        System.out.println("无参构造");
    }
    {
        System.out.println("实例代码块");
    }
    static {
        System.out.println("静态代码块");
    }
}

public class Test {
    public static void main(String[] args) {
        new  Demo();
    }
}

运行结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Xu9iFfEe-1637045557769)(C:Users戴尔AppDataRoamingTyporatypora-user-images1636981756291.png)]

public class Test {
    public static void main(String[] args) {
        System.out.println(Demo.car);
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SPbxRv8F-1637045557773)(F:笔记截图代码块)]

类在什么时候加载？

• 类在程序执行时加载；
• main方法在哪个类中执行，这个类加载；
• 创建某个类的对象；
• 调用某个类中静态属性，方法。

包（package)

• 为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
• 包可以更好得管理逻辑相关的类，可以控制不同包之间的访问权限
• 导入外部包的类：关键字“import“

包的作用：

• 避免类重名
• 按照不同功能管理类
• 控制访问权限

包的命名规范：

在包名中，可以使用.号来区分包的级别；包名一般情况下是小写

第一级 指该项目的类型，如com,org,gov等，

第二级 指项目所开发或者运行的公司名称，如：oracle,sun,huawei等

第三级 指项目的名称，如：bcms,oa,erp,cms等

第四级 指项目模块的名称，如：bean,action,exception等

访问权限修饰符

用来修饰类，成员变量，成员方法，内部类，控制对齐访问的权限。

访问权限和包是密切相关的；

Java语言有四个权限访问修饰符，权限从大到小依次为：

（1）public（ 公共访问级别）：公共权限 修饰类、属性、方法。可以被任意类访问

（2）protected（子类访问级别）：受保护的权限 修饰属性、方法。

可以被同包类访问，如果不是同包类，必须是该类的子类才可以访问。

（3）default（包访问级别）：同包权限 修饰类、属性、方法。只能被同包的类访问

（4）private（当前类访问级别）：私有权限修饰属性、方法。 只能在本类中访问

	public	protected	default	private
同类	√	√	√	√
同包	√	√	√
不同包子类	√	√
不同包的其他类	√

面向对象特征 面向对象语言的三大特征：

• 封装
• 继承
• 多态

封装

将类的某些信息隐藏起来（用到访问权限修饰符来实现），不让在在外部直接对其访问，而是通过该类所提供的方法来实现对内部信息的操作访问。

public class Dog {
    private String name;
    public Dog() {

    }


    public Dog(String name) {
        if (name != null) {
            this.name = name;
        }
    }
    public void eat(){

    }
    public void setName(String name){
        if (name != null){
            this.name = name;
        }
    }
    public String getName() {
        return this.name;
    }
}
class Test{
    public static void main(String[] args) {
        Dog dog = new Dog("二哈");
        Dog dog1 = new Dog();
        dog1.setName("旺财");
        System.out.println(dog1.getName());
    }
}

输出：旺财

继承

使用extends关键字，一个类只能直接继承一个父类，继承后子类就可以使用父类中非私有的成员。

在类的继承中有如下几种情况需注意：

1.一个类只能有一个直接父类

2.多个类可以继承一个父类

3.继承具有传递性：C继承B，B继承A，那么C类就具有B，A类中非私有的属性和方法

4.一个类的父类可以再去继承另外的父类

输出为：

name=拉布拉多犬
动物发出叫声

重写父类方法

在继承关系中，子类会自动继承父类中公共的方法，但有时在子类中需要对继承的方法进行一些修改，即对父类的方法进行重写。子类中重写的方法需要和父类被重写的方法具有相同的方法名、参列表以及返回值类型。

public class Animal {
    //定义动物叫的方法
    void shout(){
        System.out.println("动物发出叫声");
    }
}

//定义Dog类继承Animal类
class Dog extends Animal{
    //定义狗叫的方法
    void shout(){
        System.out.println("汪汪");
    }
}

//定义测试类
class Test{
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.shout();    //调用Dog类重写的shout()方法
    }
}

输出：汪汪

super关键字

super关键字用途

• 使用super关键字访问父类成员

• 用super.成员变量名来引用父类成员变量

• 用super.方法名（参数列表）访问父类的方法。

• 用super.构造方法(参数列表)访问父类构造方法

class AnimalDemo {
    String name = "猫";
    void eat(){
        System.out.println("猫吃食物");
    }
}

class Cat extends AnimalDemo{
    String name = "猫类";
//重写父类的eat()方法
    @Override
    void eat() {
        super.eat();
    }
    void printName(){
        System.out.println("猫的名字是："+super.name);
    }
}

 class TestDemo{
    public static void main(String[] args) {
      Cat cat = new Cat();
      cat.printName();
      cat.eat();
    }
}

输出为：

猫的名字是：猫
猫吃食物

Object类

在Java中提供了一个Object类，它是所有类的父类。

当一个类没有显示的继承某个类，那么这个类默认继承Object类。

抽象类 ● 抽象方法

• 抽象方法是一种特殊的方法：它只有声明，而没有具体的实现.

• 抽象方法必须用abstract关键字进行修饰，在定义方法时不需要实现方法体.

• 当一个类中包含了抽象方法，那么该类也必须使用abstract关键字来修饰.

• 抽象类可能包含了抽象方法，也可能不包含抽象方法.
• 如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类.

● 特点:

抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法， 所以不能用抽象类创建对象

如果想调用抽象类中定义的抽象方法，需要创建一个子类，在子类中实现抽象类中的抽象方法

抽象类及抽象方法定义的基本语法格式：

//定义抽象类
[访问权限修饰符] abstract class 类名{
//定义抽象方法
[访问权限修饰符] abstract 方法返回值类型 方法名（）;
//其他方法或其他属性
}

多态 多态概述

多态：同一种事物，在不同时刻表现不同的状态

条件：要有继承关系（类继承类，类继承抽象类，类实现接口）

多态存在的三个必要条件

● 要有继承（包括接口的实现）(前提条件)

● 要有重写(前提条件)

● 父类引用指向子类对象

多态环境下对成员方法、静态成员方法、对成员变量的调用

public abstract class Animal {
    int age = 10;
    public abstract void eat();
    public void sleep(){
        System.out.println("动物睡觉");
    }
    public static void play(){
        System.out.println("动物玩耍");
    }
}
class Dog extends Animal {
    int age = 20;
    @Override
    public void eat() {
        System.out.println("Dog重写Animal中的eat（）---狗吃饭");
    }
    public void cute(){

    }
}
 class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
class Test {
    public static void main(String[] args) {
        Dog a = new Dog();
        
        Animal b = new Dog();
        b.eat();
        b.sleep();
        
        b.play();
        
        System.out.println(b.age);
    }
}

运行结果：

Dog重写Animal中的eat（）—狗吃饭
动物睡觉
动物玩耍
10

多态转型

自动转型：子 继承 父

向上转型：子类型 自动转为（上升为） 父类类型

Animal dog = new Dog();

强制转型: 向下转型 父类类型 转为 子类自己的类型

优缺点: 父类引用表示子类对象,提升程序的扩展性

缺点: 父类类不能调用 子类中特有的方法

public abstract class Animal {
    int age = 10;
    public abstract void eat();
    public void sleep(){
        System.out.println("动物睡觉");
    }
    
}
class Dog extends Animal {
    int age = 20;
    @Override
    public void eat() {
        System.out.println("Dog重写Animal中的eat（）---狗吃饭");
    }
    public void cute(){

    }
    public static void play(){
        System.out.println("狗玩耍");
    }
}
 class Monkey extends Animal {
    @Override
    public void eat() {
        System.out.println("猴子吃香蕉");
    }
}
class Test2 {
    public static void main(String[] args) {

        Animal dog = new Dog();
        Monkey monkey = new Monkey();
        Test2 t = new Test2();
        t.feedAnimal(dog);
        t.feedAnimal(monkey);

    }
    //喂动物
    public void feedAnimal(Animal animal){
        animal.eat();       //判断animal中实际传入的类型是什么
        
        
       
        System.out.println(animal instanceof Dog);
        if(animal instanceof Dog){
            Dog dog = (Dog)animal;
            dog.play();
        }
    }
}

注：instanceof关键字可以判断一个对象是否为某个类（或接口）的实例或者子类实例

final关键字

final 用于声明属性，方法和类。

修饰类：该类不能被其他类继承

修饰方法：当一个类的方法被final关键字修饰后，这个类的子类将不能重写该方法

• 属性:定义就必须直接赋值或者在构造方法中进行赋值，并且后期都不能

修改。

• 方法:子类里不可以重写。

• 类:不能被定义为抽象类或是接口,不可被继承。

public class Car {
    final int num; //在定义之初没有对其赋值，则要在构造方法中进行赋值
    static  final  int a = 10;//在定义之初就为其赋值，那么所有对象不能改变其值，所有用static修饰
    public Car(int num) {
        this.num = num;
    }
    public final void run(){

    }
}

接口 接口概述

1.如果一个抽象类中所有方法都是抽象的，则可以将这个类定义为Java中的另一种形式：接口；接口是一种特殊的抽象类，这种抽象类中包含抽象方法。

2.接口: 如：USB接口 规范的定义(定义口的大小,如何传输数…)

接口类似于抽象类( 可以看做是一个更彻底的抽象类 )

接口和抽象类 都是用于在顶层类,指定规范(设计功能).

接口由interface修饰

3.接口存在的意义：

java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑 。

4.接口中没有构造方法，不能创建对象

5.接口也表示抽象（功能设计），也是需要其他类来实现的（继承）

6.接口特点：

（1）JDK8之前接口只能定义静态常量和抽象方法；JDK8之后接口增加了静态方法，默认方法

（2）一个接口可以继承多个接口

（3）一个类可以实现多个接口

（4）一个类只能直接继承一个类

 public interface Animal {
//     public  static final int num = 10;
    int num = 10;//接口中的成员变量默认是静态变量
//    public abstract   void eat();
     void eat();
     //静态方法直接通过接口名调用
     public static void testStatic(){

         System.out.println("testStatic");
     }
     //默认 通过子类对象调用
     public default void testDefault(){

         System.out.println("testDefault");
     }
}
class Dog implements Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}
class Cat implements Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
class Test {
    public static void main(String[] args) {
        System.out.println(Animal.num);
        Animal.testStatic();
        Animal dog = new Dog();
        Animal cat = new Cat();

    }
    public void feedAnimal(Animal animal){
        animal.eat();
    }
}