JAVASE----基础（面向对象）

最新推荐文章于 2023-10-13 17:38:56 发布

zkw_sunflower

最新推荐文章于 2023-10-13 17:38:56 发布

阅读量140

点赞数

分类专栏：知识整理文章标签： java 多态

本文链接：https://blog.csdn.net/zkw129/article/details/111301712

版权

知识整理专栏收录该内容

9 篇文章 0 订阅

订阅专栏

面向对象

概念

面向对象程序设计（Object Oriented Programming，OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。OOP=对象+类+继承+多态+消息，其中核心概念是类和对象。

类和对象

类

类是对现实生活中一类具有共同特征的事物的抽象（ Java语言最基本单位，可以理解为模板或者设计图纸）

定义类
形式：class 类名 {}
定义类名时遵守大驼峰命名规则(XxXxXx)

对象

对象是类的具体的实现，每个对象具有三个特点。
对象的状态：描述对象的基本特征（成员变量）
对象的行为：描述对象的功能（成员方法）
对象的标识：对象在内存中都有一个唯一的地址
创建对象
形式：类型变量名 = new 类型（）;
定义变量名时遵守小驼峰命名规则(xxXxXx)

类和对象的关系

在这里插入图片描述
假如汽车是一个类，则宝马，大奔就可以分别看作是汽车的对象

对象在内存中的存储

在这里插入图片描述

封装

概念

封装即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别。

特点

使用private关键字修饰属性，使其私有化，想要访问或修改，只能使用公共的get()和set()方法。

优点

提高安全性（属性私有化）
提高重用性（提取共性代码）

程序演示

public class Student {
//String name;
       //把属性隐藏起来
       private String name;
       //设置公共的赋值方法
       public void setName(String n){
              name=n;
       }
       //设置公共的取值方法
       public String getName(){
              return name;
       }     
       int age;
}
class StDemo{
       public static void main(String[] args) {
              Student s = new Student();
              //不能访问私有的
              //s.name="zhangsan";
              //System.out.println(s.name);s
              //利用setXxx()给属性赋值
              s.setName("zhangsan");
              //利用getXxx()给属性取值
              System.out.println(s.getName());
       }
}

继承

概念

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为

特点

1、使用extends关键字
2、相当于子类把父类的功能复制了一份
3、 java只支持单继承
4、继承可以传递（爷爷，儿子，孙子的关系）
5、不能继承父类的私有成员
6、继承多用于功能的修改，子类可以拥有父类的功能的同时，进行功能拓展
7、像是is a 的关系

优点

提高父类代码的复用性,减少子类代码的编写,提高开发效率

程序演示

public class TTT {
       public static void main(String[] args) {
              Zi zi = new Zi();
              zi.speak();
              System.out.println(zi.skin);
              System.out.println(zi.addr);
       }
}
 
class Fu{
       String skin="黄种人";
       String addr="大成都";
      
       public void speak(){
              System.out.println("Fu...speak()");
       }
}
 
//通过extends和父类发生继承关系
//所有父类的功能，子类都可以继承过来，注意不能是private的
class Zi extends Fu{
       //什么都不写，能不能把父亲的内容复制一份出来
}

多态

1、多态的前提是继承+方法的重写
2、父类引用指向子类对象,如：Animal a = new Dog();//Dog extends Animal
3、多态中，编译看左边，运行看右边
使用特点
1、成员变量：使用的是父类的
2、成员方法：由于存在重写现象所以使用的是子类的
3、静态成员：随着对象而存在，谁调用的就返回谁的

优点

做出通用编程,本质上就是不关心具体的子类的类型,屏蔽了子类之间的不同,可以把子类当做父类来看
提高程序的扩展性和可维护性

程序演示

public class p {
       public static void main(String[] args) {
              Animal an = new Dog();//父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。
              an.eat();//只可以用父类的功能，这就统一了调用的标准
              //狗吃肉,由于eat()发生了重写，所以父类方法被覆盖掉了
       }
}
class Animal{
       public void eat(){
              System.out.println("大小通吃");
       }
}
class Dog extends Animal{
       public void kanjia(){
              System.out.println("狗可以看家");
       }
       public void eat(){
              System.out.println("狗吃肉");
       }
}

构造方法

概念

构造方法是一种特殊的方法，它是一个与类同名且返回值类型为同名类类型的方法。对象的创建就是通过构造方法来完成，其功能主要是完成对象的创建或者对象的初始化。当类实例化一个对象时会自动调用构造方法。
构造方法和其他方法一样也可以重载。

形式与特点

形式
修饰符类名（含参或无参）{…}
特点
定义类时，系统会默认该类拥有一个无参构造，但当我们定义一个含参构造后，无参构造不再默认拥有，需要手动定义

程序演示

public class Constructor {
       String name;
        //当存在一个含参的构造方法时，无参构造将不再自动生成...    
        //public Constructor(){}
        //含参构造
       public Constructor(String n){
              name=n;
       }
       void eat(){
              System.out.println("Constructor.eat()");
       }
}
class cc{
       public static void main(String[] args) {
//注释掉无参的构造也可以运行，说明系统会自动提供一个无参的构造方法
              Constructor c1 = new Constructor();
              c1.eat();        
//c1是引用变量，引用的是对象的地址值。
              //根据地址值找到对象，并获取对象的数据
              Constructor c2 = new Constructor("张三");
              System.out.println(c2.name);
       }
}

构造代码块和局部代码块

构造代码块

1、在类的内部，方法外部，的代码块。
2、通常用于抽取构造方法中的共性代码。
3、每次调用构造方法前都会调用构造代码块
4、优先于构造方法加载

class c{
       String country;
       {
              country="中国";
       }
       public c() {
              System.out.println("1号选手，来自"+country);
       }
       public c(int a) {
              System.out.println("2号选手，也来自"+country);
       }
}

局部代码块

1、在方法里面的代码块
2、通常用于控制变量的作用范围，出了括号就失效
3、变量的范围越小越好，成员变量会有线程安全问题
4、总结：执行顺序：
构造代码块是最优先的，局部代码块顺序执行

重载和重写(Overload&Override)

1、重载：是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
2、重写：是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型
3、重写是父类与子类之间多态性的一种表现
4、重载是一类中多态性的一种表现

程序演示

重载

public class OverLoad {
       public static void main(String[] args) {
              int a=10;
              int b=20;
              String name="lisi";
              f1();
              f1(a);
              f1(a,b);
              f1(a,b,name);
       }
       private static void f1(int a, int b, String name) {
              System.out.println(a+b+name);//30name
       }
       private static void f1() {
              System.out.println("f1()");
       }
       private static void f1(int a) {
              System.out.println(a);
       }
       private static void f1(int a, int b) {
              System.out.println(a+b);
       }     
}

重写

public class Override {
       public static void main(String[] args) {
              Sub3 s=new Sub3();
              s.testShow();//调用普通方法，
              s.eat();//调用重写方法，子类已经重写了父类的方法，从此再用，就是儿子的实现方式
       }
}
class Fu3{
       public void show(){
              System.out.println("Fu...show()");
       }
       public void eat(){
              System.out.println("爸爸吃肉");
       }
}
class Sub3 extends Fu3{
       //普通方法
       public void testShow(){
              super.show();//调用父类的eat()
       }
       //重写方法
       //方法签名完全一致的情况就是发生了重写
       public void eat(){
              System.out.println("儿子吃肉");
       }
}

访问控制修饰符

public
允许跨工程访问的类
protected
允许同包类+子类访问
default
（不写修饰符默认隐藏）同包类
private
只允许本类访问

权限大小比较

在这里插入图片描述

this和super关键字

this

this代表本类对象的一个引用对象。
–构造函数中，this()必须放在第一行。
–当局部变量和成员变量同名时，用于区分。
–构造方法之间互相调用

程序演示

public class Test_This {
    public static void main(String[] args) {
        new Demo().test();//通过对象,来访问类里的成员(成员变量和成员方法)
    }
}    
class Demo{
    int count = 20 ;//成员变量
    public void test() {
        int count = 10;//局部变量
        System.out.println(count);//10,变量的就近原则,会使用局部变量 的值 
        //想要使用  和  局部变量 同名的 成员变量count--this调用成员变量
        //this表示的是本类的对象的引用--底层帮你new了一个本类对象--Demo this = new Demo();
        System.out.println( this.count );//20,成员变量
    }
}

super

super代表父类对象的一个引用对象
–通过super关键字可以使用父类的内容
–如果用super，必须出现在调用位置的第一行

public class Test_Super {
public static void main(String[] args) {
    new Zi3();    //父类无参构造
                  //子类无参构造
    new Zi3("含参"); //父类含参构造
                    //子类含参构造
}
}

class Fu3{
//如果父类有含参构造，子类找不到无参构造，需要在子类中使用super去调用父类的含参构造    
    public Fu3(String name) {
        System.out.println("父类含参构造");
    }
    pulic Fu3(){
		  System.out.println("父类无参构造");
}
}
class Zi3 extends Fu3{
    public Zi3() {
        //super()；如果没有super，在此处隐藏了--子类的构造方法中都会隐藏着父类的无参构造
        super();
        System.out.println("子类无参构造");
    }
    public Zi3(String name) {
        //此处也隐藏了super();证明子类每一个构造都隐藏了父类无参构造
        super("含参");
        System.out.println("子类含参构造");
    }

}

this和super比较

1、 this代表本类对象的引用，super代表父类对象的引用。
2、 this用于区分局部变量和成员变量
3、 super用于区分本类变量和父类变量
4、 – this.成员变量 — this.成员方法() — this(参数)代表调用本类内容
5、 --super.成员变量–super.成员方法()–super(参数)代表调用父类内容
6、 this和super不可以同时出现在同一个构造方法里，他们两个只要出现都得放在第一行，同时出现的话，到底第一行放谁呢。

static和final关键字

static

static用于修饰成员（变量&方法），使其成为静态资源。

特点

1、可以修饰成员变量，成员方法
2、随着类的加载而加载，优先于对象加载
3、只加载一次，就会一直存在，不再开辟新空间
4、全局唯一，全局共享
5、可以直接被类名调用
6、静态只能调用静态，非静态可以随意调用
7、 static不能和this或者super共用，因为有static时可能还没有对象

public class Test_Static {
    public static void main(String[] args) {
        //2,静态资源优先于对象加载,因为是随着类的加载就已经加载了
        Student.coding();//null
                        //正在敲代码
        System.out.println(Student.name);//null
        Student s = new Student();
        s.study();//10
                   //null
                   //null
                  //正在敲代码
                  //正在学习java
        System.out.println(s.age);//10
        //1,静态资源,多了一种访问方式,除了可以用对象访问,更提倡用类名直接调用
        Student.coding();//null
                          //正在敲代码
        System.out.println(Student.name);//null
        //3,静态资源是共享资源,能够被多个对象共享
        Student s1 = new Student();
        s1.name="张三";
        Student s2 = new Student();
        System.out.println(s2.name);//张三
    }
}
class Student{
    //普通资源 
    int age = 10;
    public void study() {
        //6,非静态调用关系? -- 调用任意资源
        System.out.println(age);
        System.out.println(name);
        coding();
        System.out.println("正在学习java");
    }
    //静态资源
    static String name ;
    static public void coding()  {
        //4,静态资源里,不能使用this或者super关键字!
        //this.study();
        //super.
        //5,静态调用关系? -- 只能调用静态,不能调用非静态的
        System.out.println(name);
        System.out.println("正在敲代码");
    }
}