Java学习第八天面向对象2

最新推荐文章于 2024-07-16 16:36:17 发布

Java初学者10101010

最新推荐文章于 2024-07-16 16:36:17 发布

阅读量95

点赞数

分类专栏： java 文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/m0_53400592/article/details/126146950

版权

java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

7.6 this关键字

概念：代表调用者本身

作用：

\1. 区分局部变量和全局变量

\2. 调用本类中其他方法(普通方法和构造方法)

\3. 在调用本类中其他构造方法时，必须写在第一行

7.7 第一大特征-封装

私有的 private

private 数据类型属性名称

需要做set/get公有方法：

set属性名首字母大写无返回值有参数

get属性名首字母大写有返回值无参数

public class Person {
    private int id;
    private  String useName;
    private  String passWord;
    private  int age ;
    private int height;
    public static Person person =new Person();//私有方法的调用  在属性里面实例化
    private Person(){

 }
  public static Person getPerson(){
        return person;
    }

7.8 static静态

放在静态区的，一般用public static修饰

如果一个变量被public static修饰，那一般还会有另外一个关键字final配合使用

static可以用来修饰方法,叫做静态方法，那么可以通过类名直接调用

static还可以用来修饰类

静态的方法可以访问静态的成员

非静态的方法可以访问静态的成员

静态的方法不可以访问非静态的成员

static 代码块优先执行于任何代码而且只执行一次

static{
  System.out.print("优先执行");
      
}

7.9、==特征==：继承（extends）

使用继承可以为一系列相关对象定义共同特征的一般类，然后其他类(更特殊的类)可以继承这个一般类，每个进行继承的类都可以添加其特有的内容

==被继承的类称为超类(super class）/父类,继承的类称为派生类/子类(subclass）==

1）语法

子类 extends 父类
    
public class person{//父类
    private int id;//编号
    private String name;//姓名
    private String phone;//电话

    public Person() {
    }

    public Person(int id, String name, String phone) {
        this.id = id;
        this.name = name;
        this.phone = phone;
    }

    public Person(String name, String phone) {
        this.name = name;
        this.phone = phone;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }
    
    public void study(){
        System.out.println("父类学习");
    }
}

public class Student extends Person {//子类
    public void n(){
        setName("阿斯顿");
        System.out.println(getName());
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.n();
    }
}

2）注：

一旦创建了一个定义一系列对象共同特征的超类，就可以使用该超类创建任意数量的更特殊的子类

子类可以使用父类中的==非私有类型==（除了private）的方法或属性

Java只支持单继承，不支持多继承（一个子类只能有一个父类，一个父类能有多个子类）

Java支持多重继承（继承体系）

不要仅为了获取其他类中某个功能而去继承

==继承时自动继承父类的构造方法==

如果一个类想要使用另外一个类的成员，有两种办法：继承，传参

3）方法的重写

当子类出现和父类一模一样（包括方法名，参数类型，参数个数）的方法时，出现方法的覆盖操作或者重写或者复写

当有重写现象发生时，子类执行方法则执行重写之后的方法，且不能再调用父类被重写的方法

重写的修饰符访问权限不能比被重写方法更高

4）注解（@Override）

==注解不是注释==

表示这个方法是一个重写方法（父类中有这个方法）

==限制==：这个方法跟父类中的方法一模一样（包括方法名和参数）

public class Student extends Person {//子类
    @Override//注解，表示下一个方法为重写方法
    public void study() {
        super.study();
    }
}

7.10、super

调用父类中的（非私有）方法或（非私有）属性，使用方法和this类似

==子类继承父类时自动继承父类的构造方法==

==调用构造方法时super与this不能同时使用==

super.父类成员非私有属性
super.父类中的非私有方法
super()//调用构造方法，隐式存在且只能在第一行
    
public class Student extends Person {
    @Override//注解
    public void study() {
        System.out.println(super.getName() + "学习");
        super.study();
    }
    
    public Student(){
        super();//不写默认隐藏存在
    }
}

7.11、Object类（所有类的基类）

类0bject 是类层次结构的根类。每个类都使用0bject作为超类。所有对象（包括数组）都实现这个类的方法。

下面的方法都为Object类中的方法

1）toString

返回该对象的字符串表示

通常，toString方法会回一个“以文本方式表示”此对象的字符率。结果应是一个简明但易于读懂的信息表达式

==建议所有子类都重写此方法==

Student student = new Student();
System.out.println(student.toString());
System.out.println(student);//直接输出对象时默认调用toString方法输出其地址

7.12、修饰符

定义default方法时不能写修饰符

void aaa(){
}

7.13、关键字：final

修饰类：修饰后不能被继承（一般不修饰类）

修饰成员属性：需要初始化成员属性，一般用public static final 修饰，被当作常量，属性名建议用大写

修饰方法：被修饰的方法不能被重写

public final class 类名
public static final 数据类型 属性名;
public final void 方法名(){}

7.14对象传参

想要用其他类中的属性和方法但是两个类无继承关系则用对象传参

package com.xszx.beans;

public class Person {

    protected String phone="1232";
    private String name;
    private  int id;
    int age=1;
    public static final int A=12;

    public final void work(){//用final被修饰的方法不能被重写
        System.out.println("KKK");
    }

    public Person() {
    }

    public Person(String name, int age, String phone) {
        this.name = name;
        this.age = age;
        this.phone = phone;
    }

    public Person(String name, int id, int age, String phone) {
        this.name = name;
        this.id = id;
        this.age = age;
        this.phone = phone;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }



}
---------------------------------------------------------------------------


package com.xszx.beans;

public class Student extends Person {



    /*public void work(Person person) {
        System.out.println(person.age);//若不继承person 则必须用对象传参来调用成员变量
    }*/

//    @Override                 因为方法work 被final修饰 所以不能重写方法
//    public void work() {
//        super.work();
//    }
}
------------------------------------------------------------------------------
  package com.xszx.test;

import com.xszx.beans.Person;

public class Teacher extends Person {
//    @Override
//    public void work() {
//        super.work();
//    }
    //public void work2(Person person){
       // System.out.println(person.age);//因为age属性 使用的是default 它最大级别是包级别 跨包调 用对象传参也不行
    //}
   public void  work3(){
        System.out.println(phone);
        }
     }
------------------------------------------------------------------------------------
package com.xszx.test;

import com.xszx.beans.Person;
import com.xszx.beans.Student;

public class Test {
    public static void main(String[] args) {

        Student student = new Student();
      //  student.work();
        Person person = new Person();
        final Teacher teacher = new Teacher();
       // student.work(person);
        teacher.work3();

    }
}