封装继承多态2

最新推荐文章于 2024-08-04 11:07:52 发布

123嗯

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量65

点赞数

文章标签： java

本文链接：https://blog.csdn.net/deathseeks/article/details/111241681

版权

封装继承多态

1.封装

概述：

隐藏对象的属性和实现细节，对外提供公共的访问方式。

原则：

不需要用户访问的内容隐藏起来

package org.wdit.unti08;
/**
 * 标准类第一版
 * 1.私有化成员变量
 * 2.提供公共的访问方式：setXxx()/getXxx()
 */
public class Student2 {
    private String name;//姓名
    private int age;//年龄
    public String getName(){
        return name;
    }
    public void setName(String name){

        this.name=name;
    }
    public static void main(String[] args) {
        Student2 student=new Student2();
        student.age=20;
        System.out.println( "该同学年龄为："+student.age);
        student.setName("赵童");
        System.out.println("该同学名字为："+student.getName());


    }


}

2.private关键字

1.它是一个权限修饰符

2.成员变量和成员方法

3.被它修饰的成员变量和成员方法只能在本类中被访问，如果其他类想访问，就必须提供公共的访问方式。3.封装和private的应用

3.封装和private的应用

1.私有化成员变量

2.提供公共的访问方式: getXxx() / setXxx()

4.this关键字

概述：

1.表示当前类的对象

2.谁调用该方法，该方法内部的this就代表谁

3.解决局部变量和成员变量的同名问题

5.构造方法

概述：

初始化类的对象，并对对象的属性进行初始化

格式：

1.没有返回值一项

2.方法名和类名完全相同

package org.wdit.unti08;
//练习
public class Student3 {
    //成员变量
   private String Dell;
   private int price;
   private String color;
   //构造方法
    public Student3(){

    }
    public Student3(String Dell,int price,String color){
        this.Dell=Dell;
        this.price=price;
        this.color=color;
    }
//   //成员方法
    public void setPrice(int price){
        this.price=price;
   }
    public void setDell(String Dell){
        this.Dell=Dell;
    }
    public void setColor(String color){
        this.color=color;
    }
    public String show(){
        return Dell;
    }
    public String show1(){
        return color;
    }
    public int show2(){
        return price;
    }
    public void show3(){
        System.out.println(2000);
        System.out.println("红色");
        System.out.println("拯救者");


    }
    public void show4(){
        System.out.println(Dell+"\n"+price+"\n"+color);


    }




}
class Student3Demo{
    public static void main(String[] args) {
        Student3 computer= new  Student3();
      computer.setDell("戴尔");
      computer.setPrice(5999);
      computer.setColor("黑白色");
      System.out.println(computer.show());
      System.out.println(computer.show1());
      System.out.println(computer.show2());
        computer.show3();
        Student3 computer1= new  Student3("惠普",4999,"黄");
        System.out.println(computer1.show());
        System.out.println(computer1.show1());
        System.out.println(computer1.show2());
        Student3 computer2= new  Student3("惠普暗影精灵",4998,"紫");
        computer2.show4();

注意事项：

1。如果我们没有给出构造方法，系统会隐形给定一个无参构造法

2.如果我们给出了构造方法，无论是有参还是无参，系统都不在隐式给出构造方法

6.static 关键字

概述：

正对对象中，有公共属性这种情况，Java提供了一个关键字来解决资源共享问题：static

特点：

1.随着类的加载而加载

main方法

public static void main(String[] args)

2.先于对象存在

3.被该类的所有对象共享（判断是否被static关键字修饰的依据）

4.通过类名直接调用

注意事项：

1.静态方法中不能出现this关键字

2.静态方法中只能调用静态的方法或静态的属性

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

1.所属不同

静态变量-类

成员变量-对象

2.储存位置不同

静态变量-方法区的静态区

成员变量-堆内存

3.生命周期不同

静态变量-随类的加载而加载，随类的消亡而消亡

成员变量-随着对象的产生而产生，随着对象消亡而消亡

4.使用方式不同

静态变量-通过类名直接调用

成员变量-通过对象名调用

API使用

步骤：

1.打开API

2.左上角—索引—输入要查询的类

3.查看类的组成

1.成员变量字段摘要

2.成员方法方法摘要

3.构造方法构造摘要

4.学习构造方法

1.有构造方法:按照格式去创建

2.无构造方法:它的属性和方法一般都是被static修饰，直接通过类名调用即可

5.学习成员变量

6.学习成员方法

1.变量和类型

1.是否被static修饰

2.是否有返回值：方法返回什么我们用什么接收

2.方法：

1.方法名：有些方法很像，容易调错

2.参数列表：方法需要什么类型的参数，需要几个，按要求给它就可以

9.代码块

概述：被一对花括号包裹的代码就叫代码块

局部代码块：

局部位置：用于限定变量的生命周期

构造代码块：成员变量

1.先于构造方法执行，只要执行构造方法，它都会被执行

2.将多个构造方法相同的代码放到构造方法块中，对对象进行初始号操作

静态代码块：成员位置

1.随着类的加载而执行

2.只执行一次

3.对类进行初始化

静态代码块，构造代码块，构造方法三者执行顺序

1.静态代码块

2.构造代码块：只要调用构造方法，它都会先于构造方法执行

3.构造方法

package org.wdit.unti08.daimakuai;

    class Father8 {
        static {
            System.out.println("静态代码块Father");
        }

        {
            System.out.println("构造代码块Father");
        }

        public Father8() {
            System.out.println("构造方法Father");
        }
    }

    class Son8 extends Father8 {
        static {
            System.out.println("静态代码块Son");
        }

        {
            System.out.println("构造代码块Son");
        }

        public Son8() {
            System.out.println("构造方法Son");
        }
    }

    class ExtendsTest2 {
        public static void main(String[] args) {
            Son8 son = new Son8();
        }
    }

/**
 * 答案：静态代码块Father
 * 静态代码块Son
 * 构造代码块Father
 * 构造方法Father
 * 构造代码块Son
 * 构造方法Son
 */

10.继承

通过演示案例，我们发现，连个类中有许多相同的代码，如果我们继续定义警察类，工人类等,复的代码会越来越多。能不能把这些相同的代码提取出来,定义到-个单独的类中，并让这多个类与这个提取出来的类产生-个关系，有了这个关系之后，就可以让这多个类具有这个提取类中的属性和功能。为了实现这个效果，Java提供了一个技术:叫做继承.

概述：

把多个类中相同成员提取出来，定义到一个独立的类中。然后让这多个类与这个独立的类产生-个关系,多个类就具备了这个独立类中的属性和功能，这个关系就叫做继承。

关键字：

extends

格式4：

class 子类 extends 父类{

}

优点：

1.提高了代码的复用性

2.提高了代码的可维护性

3.多态的前提

缺点：

1.类于类之间的耦合性增强

2.打破了封装性

特点：

1.单继承：只能有一个父类

2.多层继承：父类也可以有自己的父类

注意事项：

1.子类只能继承父类非私有的成员变量和方法

2.子类不能继承父类的构造方法

3.继承使用场景“is a"

4.当父类的成员变量与子类的成员变量同名时

1.在子类的局部变量中找

2.在子类成员变量中找

3.在父类成员变量中找

4.还找不到就报错

11.super关键字

概述：

super关键字代表的是父类对象

用法：

1.访问成员变量

super。成员变量

2.访问构造方法

super（。。。）

3.访问成员方法

super.成员方法（）

12.继承中构造方法的关系

1.子类中所有的构造方法都默认的访问父类的无参构造方法

原因：因为集成的关系，子类对象可以使用父类的非私有属性和方法，所以在创建子类对象前，必须对父类的数据进行初始化（创建对象）

2.所有子类的构造方法，第一句默认都是：super（）

3.如果父类中没有无参构造方法，将无法创建子类对象

解决方法：

1，在父类中添加无参构造

2，同super关键字指定访问父类的有参构造

3，子类可以通过this调用本类中的其他构造方法，但是被构造的方法必须手动调用父类的有参构造

4.this（）和super（）都必须是构造方法的第一句，并且不能同时出现

13.继承中的成员方法的关系

1.先在子类中找

2.如果子类在找不到，就在父类中找

3.都找不到就报错

14.方法的重写:

子类和父类中的方法声明完全相同时，就会发生方法的重写

方法的重载:

一个类中具有多个方法名相同，但是参数列表不同的情况，叫做方法的重载

重写的应用：

可以重写父类的方法，使子类中既有父类中的方法，也可以有自己特有的方法

注意事项：

1.父类的私有方法不能被重写

2.子类重写父类的方法，访问权限不能降低

3.子类重写父类的静态方法时，也必须通过静态方法去重写（它不是方法重写，但形式与重写相似）

15.final关键字

修饰：类，方法，变量

修饰类：类不能被继承

修饰方法：不能被重写

修饰变量：

基本数据类型：初始化后，其值不能改变

引用数据类型：引用数据类型地址不能改变，数据可以改变

注意事项：

被final修饰的对象必须在狗照方法执行完毕前被初始化

2.只能赋值一次

package org.wdit.unti08.extend;

public class ExtendsDemo2 {
    public static void main(String[] args) {
        Zi2 zi=new Zi2();
        System.out.println(zi.name);
        zi.method();
         zi.Function();
        Zi2 zi2=new Zi2(20);
        System.out.println(zi2.age);

//       zi.method2();

//        zi.age=18;
    }

}

class Fu2 {
    int age=18;
    public Fu2(){
        System.out.println("父");
    }
    public Fu2(int age){

    }

    public String name="赵童";
//    private  int age;
    public void method(){
        System.out.println("Fu 普通方法");
    }
    private  void method2(){
        System.out.println( "Fu 是有方法");
    }
    public static void Function(){
        System.out.println("Fu Function!");
    }
}
//class Mother{
//
//}
//class GrandFu{
//
//}
class Zi2 extends Fu2{
int age=30;
    public Zi2(int age){

    }
    public Zi2(){
        System.out.println("子");
    }

    public String name="王必武";
//    private  int age;
    public void method(){
        System.out.println("Zi 普通方法");
    }
    private  void method2(){
        System.out.println( "Zi 是有方法");
    }
    public static void Function(){
        System.out.println("Zi Function!");
    }
}



/**
 * 答案
 * 父
 * 子
 * 王必武
 * Zi 普通方法
 * Zi Function!
 * 父
 * 30
 */

16.多态

概述：

同一操作作用于不同对象，可以产生不同的结果

前提：

1.继承

2.方法的重写

3.父类引用指向子类对象

成员访问的特点：

1.成员变量

编译看父类，运行看父类

2.成员方法

编译看父类，运行看子类

package org.wdit.unti08.duotai;

public class DuoTaiDemo {
    public static void main(String[] args) {
        Pets pets=new Dog();
        Pets pets2=new Cat();
        pets.voice();
        pets2.voice();


    }
}


class Pets{
    public void voice(){
        System.out.println("发出叫声");
    }
}
class Dog extends Pets{
    public void voice(){
        System.out.println("汪…………");
    }

}
class Cat extends Pets{
    public void voice(){
        System.out.println("喵…………");
    }

}
/**
 * 答案：
 * 汪…………
 * 喵…………
 */

3.构造方法

先父后子

package org.wdit.unti08.duotai;

public class Student {
    public static void main(String[] args) {
        Zi3 zi=new Zi3();
//        zi.Student();
       Fu3 fu3=new Zi3();
//        fu3.Student();
    }


}

class Fu3{
    public Fu3(){
        System.out.println("父");

    }


//    public static void Student(){
//        System.out.println("你哈");

    }

//}
class Zi3 extends Fu3{
    public Zi3(){
        System.out.println("子");

    }
//    public static void Student(){
//        System.out.println("你好");
//
    }
//}
/**
 * 答案
 * 父
 * 子
 * 父
 * 子
 */

4.静态方法

编译看父类，运行看父类

package org.wdit.unti08.duotai;

public class DuoTaiDemo2 {
    public static void main(String[] args) {
        Fu fu=new Zi();
        System.out.println(fu.num);
        System.out.println(fu.num2);
//        System.out.println(fu.num3);
//        System.out.println(fu.num4);
        fu.method();
        fu.method2();
//        fu.method3();
        fu.Function();
        fu.Function2();
    }

}
class Fu{
    public int num=10;
    public int num2=20;
    public void method(){
        System.out.println("Fu method!");
    }
    public void method2(){
        System.out.println("Fu method2!");
    }
    public static void Function(){
        System.out.println("Fu Function!");
    }
    public static void Function2(){
        System.out.println("Fu Function2!");
    }

}

class Zi extends Fu{
    public int num=30;
    public int num2=40;//1.成员变量
    
    public void method(){
        System.out.println("Zi method!");
    }
    public void method2(){
        System.out.println("Zi method2!");
    }//2.成员方法
    
    public static void Function(){
        System.out.println("Zi Function!");
    }
    public static void Function2(){
        System.out.println("Zi Function2!");
    }//3.静态方法
/**
 * 答案
 * 10
 * 20
 * Zi method!
 * Zi method2!
 * Fu Function!
 * Fu Function2!
 */


}

注意事项：

1.向上转型

Fu fu = new ZI()

2.向下转型

Zi zi=(Zi)fu

17.抽象类

概述：

用来描述抽象概念的类，叫做抽象类。抽象类中的方法不一定有具体的实现。

特点：

1.不能直接创建对象，只能通过子类去创建。

2.抽象类中不一定有抽象方法，但是有抽象方法的类，一定有抽象方法。

3.被abstract关键字修饰。

4.抽象类可以被继承，

普通子类：其子类必须重写抽象类中的抽象方法

抽象类子类：可以不用重写抽象方法

成员特点：

抽象类成员特点

- 1.成员变量:

 可以是变量，也可以是final修饰的常量，也可以是静态变量

- 2.成员方法：

 可以是抽象方法，也可以是非抽象方法

- 3.构造方法

有构造方法，但是不能被创建对象：其作用是子类访问父类的构造方法，对其数据进行初始化使用

注意事项：

1.有构造方法但不能被实例化：用于子类初始化数据

2.一个类，如果没有抽象方法，但是被定义为抽象方法，其目的是为了不让创建该类对象

3.abstract 与其他关键字的关系：

1.private：冲突关系，因为抽象方法必须被子类重写，而private修饰的方法，不能被继承，从而导致不能被重写

2.final:冲突关系，因为被final关键字修饰的方法，不能被重写

3.static：冲突关系，因为static修饰的方法是随类的加载而加载，可以直接通过类名调用，这样调用没有意义
```
package org.wdit.unti08.abstractDemo;
```

public class AbstractDemo {
public static void main(String[] args) {
//普通创建对象方式
// Pets pet=new Pets();
//多态创建对象方式
Pets pet=new Dog1();
pet.voice();
pet.eat();

      Pets pet2=new Cat2();
    pet2.voice();
      pet2.eat();

  }

}
abstract class Pets{
//叫声
public abstract void voice();
//吃东西
public abstract void eat();
}

/**

如果父类有抽象方法，则子类必须实现父类的抽象方法
*/

class Dog1 extends Pets{
  
  @Override
  public void voice() {
      System.out.println("喵。。。。。");
  }
  
  @Override
  public void eat() {
      System.out.println("鱼");
  
  }
}
class Cat2  extends Pets{
  
  @Override
  public void voice() {
      System.out.println("汪。。。。。");
  }
  
  @Override
  public void eat() {
      System.out.println("肉");
  
  }
}


```java
package org.wdit.unti08;

/**
 * 需求：
 * 动物：猫，狗
 * 共有的属性和方法：名字，年龄，次饭，碎觉
 */

public class AbstractDemo3 {
    public static void main(String[] args) {
        Pets pet= new Dog("bob",3);
        System.out.println(pet.name);
        System.out.println(pet.age);
        pet.eating();
        pet.sleeping();


        Pets pet2= new Cat("tom",2);
        System.out.println(pet2.name);
        System.out.println(pet2.age);
        pet2.eating();
        pet2.sleeping();

    }

}
abstract  class Pets{
    String name;
    int age;
    public  Pets(String name,int age){
        this.name=name;
        this.age=age;

    }

    public abstract void eating();



    public void sleeping(){
        System.out.println("碎觉");

    }
}
class Dog extends Pets{
    public  Dog(String name,int age){
        super(name,age);

    }
    public void eating(){
        System.out.println("肉");


    }



}
class Cat extends Pets{
    public Cat(String name,int age){
        super(name,age);
    }


    public void eating(){
        System.out.println("鱼");


    }



}

18.接口

概述：

接口是一系列方法声明（方法规范）的集合。一个接口中只有方法的特征，没有方法的实现，因为这些方法可以在不同的类中做不同的实现，而这些实现可以具有不同的结果。

特点：

1.定义接口关键字：interface

格式:

interface 接口名{}

2.实现接口关键字：implements

格式: class 类名implements 接口名{}

3.接口不能被创建对象，但是它可以通过多态去实例化

格式：接口名变量名=new 实现类();

4.接口的实现类：

1.标准类：重写接口中的抽象方法

2.抽象类：不必重写接口中的抽象方法。交由子类来实现

成员特点：

接口的成员特点：

1.成员变量
只能是常量（默认被final修饰）
2.成员方法
只能是抽象方法，并且默认被public abstract修饰
3.构造方法
没有构造方法

类和接口的关系：

1.类与类

继承关系：单继承，多层继承

2.类和接口

实现关系：单实现，多实现

3.接口和接口

继承关系：单继承或多继承

接口和抽象类的区别：

1.组成区别

抽象类：

成员变量：变量和常量

成员方法：可以是抽象方法，也可以是普通方法

构造方法：有构造，但不能创建对象

接口：

成员变量：常量

成员方法：抽象方法public abstract

构造方法：没有构造方法

2.关系的区别

类与抽象类：继承

类与接口：实现

抽象类与接口：实现

接口与接口：继承

3.应用的区别：

抽象类：定义继承体系中相同属性和方法

接口：类的拓展功能

形式参数是引用类型

1.类：在调用方法时，传入相应的对象（匿名对象）
```
package org.wdit.unti08.ReferenceTypeDemo;
```

public class FunctionDemo3 {
public static void main(String[] args) {
Pets3 pets4=new Pets3(“赵童”,18);
method1(pets4);

  }
public static void method1(Pets3 pets3 ){
      pets3.show();
    pets3.method();
      pets3.getSchool("西邮");
}

}
class Pets3{
private String name;
private int age;
private String school;

public Pets3(String name,int age){
      this.name=name;
    this.age=age;
      this.school=school;
}
  public void setName(){

  }
public String getName(){
      return name;
}
  public void setAge(){

  }
public int getAge(){
      return age;
}
  public String getSchool(String school){
      this.school=school;
      return school;
  }
  
  public void show(){
    System.out.println(name+"...."+age+"'''"+school);
  }
public void method(){
      System.out.println("我是王必武");
}

}
class Cats3 extends Pets3{
public Cats3(String name, int age) {
super(name, age);
}
}



2.抽象类：在方法调用时，传入抽象类的子类对象

```java
package org.wdit.unti08.ReferenceTypeDemo;

public class FunctionDemo {
    public static void main(String[] args) {
      Pets2 pets2=new Dog();
        method(pets2);

    }
 public static void method(Pets2 pets2){
        pets2.voice();

   }

}
abstract  class Pets2{
    abstract  void voice();
}
class Dog extends Pets2{


  @Override
    public void voice() {
      System.out.println("汪");
    }
}

3.接口：在方法调用时，传入的接口的实现类对象

package org.wdit.unti08.ReferenceTypeDemo;

public class FunctionDemo2 {
    public static void main(String[] args) {
        MyInterface myInterface=new Demo();
        function(myInterface);
    }
    public static void function(MyInterface myInterface) {
        myInterface.method();
    }

}
interface  MyInterface{
    public  abstract  void method();
}
class Demo implements MyInterface{

    @Override
    public void method() {
        System.out.println("重写接口中的方法");
    }
}

返回值是引用类型

1.类：在调用方法时，返回相应的对象（匿名对象）

2.抽象类：在方法调用时，返回抽象类的子类对象

package org.wdit.unti08.ReferenceTypeDemo;

public class FunctionDemo4 {
    public static void main(String[] args) {
        System.out.println(method3());
    }
    public static Pet4 method3(){
        Pet4 pet4=new Dog4();

        pet4.method();
        pet4.method2();
        pet4.getName();

        return pet4;
    }

}
abstract class Pet4{
    private String name;
    public void method(){
        System.out.println("很高兴");
    }
    public void setName(String name){
        this.name="王必武";
    }
    public String getName(){
        return name;
    }
    public abstract void method2();

}
class Dog4 extends Pet4{

    @Override
    public void method2() {
        System.out.println("嘿嘿");


    }
}

3.接口：在方法调用时，返回的接口的实现类对象

package org.wdit.unti08.ReferenceTypeDemo;

public class FunctionDemo5 {
    public static void main(String[] args) {
        System.out.println(method1());

    }
    public static Ours method1(){
        Ours ours=new My();
        ours.method();
        System.out.println(20);
        return ours;
    }

}
interface Ours{
    int num=20;
    public abstract void method();
}
class My implements Ours{
    int num=20;
    @Override
    public void method() {
        System.out.println("你好");
    }
}

19.包

概述：其实就是文件夹

作用:对类进行分类管理

关键字：package

格式：package包名：（多级包用.隔开）

注意事项：

1.package语句必须是第一条可执行语句

2.一个Java文件中，只能有一条package语句

3.没有package语句，默认就是没有包

导包：

格式：import 包名.类名

import 包名.*

20.权限修饰符

权限修饰符	本类	同包	不同包下的子类	不同包的其他类
private	√
默认	√	√
protected	√	√	√
public	√	√	√	√

常见修饰符：

1.权限修饰符：public，private，protected

2.状态修饰符：static，final

3.抽象修饰符：abstract

常用情景：

1.类

权限修饰符,抽象修饰符,状态修饰符

常用：public

2.成员变量

权限修饰符,状态修饰符

常用：private

组合：public static final

3.成员方法

权限修饰符,抽象修饰符,状态修饰符

常用：public

组合：public static

public static final

public abstract

public final

4.构造方法

权限修饰符

123嗯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
封装继承多态2

封装继承多态1.封装概述：隐藏对象的属性和实现细节，对外提供公共的访问方式。原则：不需要用户访问的内容隐藏起来package org.wdit.unti08;/** * 标准类第一版 * 1.私有化成员变量 * 2.提供公共的访问方式：setXxx()/getXxx() */public class Student2 { private String name;//姓名 private int age;//年龄 public String getName(){
复制链接

扫一扫