Java面向对象的三大特征及关键字

2021/8/2 17:07:39

编程Tag： 面向对象 Java out system public void Student println 三大

本文主要是介绍Java面向对象的三大特征及关键字，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1.封装

1.封装思想

  1. 封装概述：是面向对象三大特征之一，是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

  2. 封装原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，成员变量private（私有化），提供对应的getXxx()/setXxx()方法

  3. 封装好处：通过方法来控制成员变量的操作，提高了代码的安全性；把代码用方法进行封装，提高了代码的复用性

2.关键字private

  1. private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

  2. 被private修饰的成员，只能在本类进行访问。

  3. 针对private修饰的成员变量，如果需要被其他类使用，需要

  • 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

  • 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

/*
  学生类
*/
class Student {
  //成员变量
  private String name;
  private int age;
  //get/set方法
  public void setName(String n) {
    name = n;
 }
  public String getName() {
    return name;
 }
  public void setAge(int a) {
    age = a;
 }
  public int getAge() {
    return age;
 }
  public void show() {
    System.out.println(name + "," + age);
 }
}
/*
  学生测试类
*/
public class StudentDemo {
  public static void main(String[] args) {
    //创建对象
    Student s = new Student();
    //使用set方法给成员变量赋值
    s.setName("小石");
    s.setAge(30);
    s.show();
    //使用get方法获取成员变量的值
    System.out.println(s.getName() + "---" + s.getAge());
    System.out.println(s.getName() + "," + s.getAge());
 }
}

3.关键字this

this修饰的变量用于指代成员变量，其主要作用是区分局部变量和成员变量的重名问题

  • 方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量

  • 方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

public class Student {
  private String name;
  private int age;
  public void setName(String name) {
    this.name = name;
 }
  public String getName() {
    return name;
 }
  public void setAge(int age) {
    this.age = age;
 }
  public int getAge() {
    return age;
 }
  public void show() {
    System.out.println(name + "," + age);
 }
}

2.继承

1.继承的概念与特征

  1. 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法。

  2. JAVA中类只有单继承，没有多继承！继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。

  3. 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。extends的意思是“扩展”。子类是父类的扩展。子类和父类之间，从意义上讲应该具有“is a”的关系

  4. 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖，组合，聚合等

  5. 继承好处 提高了代码的复用性 (多个类相同的成员可以放到同一个类中) 提高了代码的维护性 (如果方法的代码需要修改，修改一处即可)

    继承坏处

    继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性

继承案例：

public class Demo1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.sayHello();
    }
}
//在JAVA中，所有的类，都默认直接或者间接继承Object
//Person 人：父类
public class Person {
    public void sayHello(){
        System.out.println("Hello!");
    }
}
//学生 is 人：派生类，子类
//子类继承了父类，就会拥有父类的全部方法
public class Student extends Person{
    
}

2.关键字super与this

①super注意点

  1. super调用父类的构造方法，必须在构造方法的第一行

  2. super必须只能出现在子类的方法或者构造方法中

  3. super和this不能同时调用构造方法

②与this的不同

1.代表的对象不同：

this：本身调用者这个对象

super：代表父类对象的应用

2.前提不同：

this：没有继承也可以使用

super：只能在继承条件才可以使用

3.构造方法：

this（）：本类的构造

super（）：父类的构造

③super使用案例

public class Demo1 {
    public static void main(String[] args) {
        Student student = new Student();
        //student.testName("a");
        //student.testPrint();
    }
}
public class Person {
    protected String name="P";
​
    public Person(){
        System.out.println("Person无参执行了");
    }
​
    public Person(String name){
        System.out.println(name);
    }
​
    protected void print(){
        System.out.println("Person");
    }
​
    //私有的方法无法被继承
    private void sayHello(){
        System.out.println("Hello");
    }
}
public class Student extends Person{
    private String name="S";

    public Student(){
        //隐藏代码：调用了父类的无参构造
        super();//调用父类的构造器，必须放在子类构造器的第一行

        //如果父类有有参构造也可以调用父类的有参构造，例如
        //super("name");

        //如果父类没有无参构造，则子类也不能有无参构造

        //this();//调用子类本身的构造器时也必须放在第一行，两者不能同时出现，否则一定报错

        System.out.println("Student无参执行了");
    }

    public void print(){
        System.out.println("Student");
    }

    public void testPrint(){
        print();//Student
        this.print();//Student
        super.print();//Person
    }

    public void testName(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
}

3.重写

1.重写的条件

需要有继承关系，子类重写父类的方法

1.方法名必须相同

2.参数列表必须相同

3.修饰符：范围可以扩大但不能缩小： public--->protected--->default--->private

4.抛出的异常：范围可以被缩小但不能扩大：ClassNotFoundException ---> Exception

重写，子类的方法和父类必须要一致，方法体不同

2.为什么需要重写？

父类的功能，子类不一定需要，或者不一定满足

3.重写案例

public class Demo1 {

    //静态的方法和非静态的方法区别很大
    //静态方法：方法的调用

    public static void main(String[] args) {

        //方法的调用只与左边定义的数据类型有关
        Student s1 = new Student();
        s1.testOv();
        s1.test();//static静态方法   A--->TEST

        //父类的引用指向了子类
        Person s2 = new Student();
        s2.testOv();
        s2.test();//static静态方法   B--->TEST
    }
}
//继承
public class Student extends Person{

    //Override：重写
    @Override//注解：有功能的注释
    public void testOv() {
        System.out.println("A--->TEST");
    }

/*        public void testOv(){
        System.out.println("A--->TEST");
    }*/

    static void test(){
        System.out.println("A--->TEST");
    }
}
//重写都是方法的重写，和属性无关
public class Person {

    public void testOv(){
        System.out.println("B--->TEST");
    }

    static void test(){
        System.out.println("B--->TEST");
    }
}

3.多态

1.多态的概念

同一个对象，在不同时刻表现出来的不同形态，即同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

2.多态存在的条件

  • 有继承关系

  • 子类重写父类方法

  • 父类引用指向子类对象

3.多态中的成员访问特点

  • 成员访问特点

    ①成员变量：编译看父类，运行看父类

    ②成员方法：编译看父类，运行看子类

4.多态的优缺点

  • 优点

    提高程序的扩展性。定义方法的时候，使用父类型作为参数，在使用时，使用具体的子类型参与操作

  • 缺点

    不能使用子类的特有成员

5.注意事项

  • 多态是方法的多态，属性没有多态

  • 父类和子类需要有联系，否则会出现类型转化异常 ClassCastException

  • 存在条件：继承关系，方法需要重写，父类引用指向子类对象

  • static 方法：属于类，它不属于实例对象，不可以重写

  • final 常量：不可以重写

  • private 方法：不可以重写

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

        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型是不确定的：父类的引用指向子类

        //Student能够调用的方法都是自己的或者是继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类型，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s1.run();
        s2.run();//子类重写了父类的方法，执行子类的方法

        s1.eat();
        ((Student) s2).eat();//强制转换
    }
}
public class Student extends Person{
    public void run(){
        System.out.println("S--->RUN");
    }
    public void eat(){
        System.out.println("S--->EAT");
    }
}
public class Person {
    public void run(){
        System.out.println("P--->RUN");
    }
}

6.关于多态的向上和向下转型(示例代码)

  • 向上转型

    父类引用指向子类对象就是向上转型

  • 向下转型

    格式：子类型 对象名 = (子类型)父类引用;

public class test {
    public static void main(String[] args) {
        //多态
        //向上转型
        Animal c1 = new Cat();
        c1.eat();//猫吃鱼
        System.out.println(c1.age);//40

        //向下转型
         Cat c2 = (Cat) c1;//Cat c2 = new Cat();
         c2.eat();//猫吃鱼
         c2.play();//猫捉老鼠
        System.out.println(c2.age);//20
        System.out.println(c2.name);//Tom
    }
}
class Animal{
    public int age = 40;
    public void eat(){
        System.out.println("吃东西");
    }
}
class Cat extends Animal{
    public int age = 20;
    public String name = "Tom";
    public void eat(){
        System.out.println("猫吃鱼");
    }
    public void play(){
        System.out.println("猫捉老鼠");
    }
}

7.关于Instanceof（类型判断）的介绍

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

        //Object--->String
        //Object--->Person--->Student
        //Object--->Person--->Teacher

        //System.out.println(x instanceof y);//看能不能编译通过，能则证明x和y是父子关系

        Object object = new Student();
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false

        System.out.println("------------------");

        Person person = new Student();
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译报错

        System.out.println("------------------");

        Student student = new Student();
        System.out.println(student instanceof Object);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Student);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错

        //类型之间的转换：父   子

        //高               低      ：低转高（自动转换）
        Person obj = new Student();
        //将此对象转换成Student对象，我们就可以使用其独有的方法了
        ((Student) obj).go();//高 转 低

        //子类转换为父类，可能丢失自己的本来的一些方法
        Student s = new Student();
        s.go();
        Person p = s;
        //p.go();//此时就不能调用go方法了

    }
}
public class Person {
    public void run(){
        System.out.println("run");
    }
}
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
public class Teacher extends Person{
    
}

4.权限修饰符与关键字(补充)

1.权限修饰符

image-20210802134734351

2.关键字final

  1. final关键字的作用

    final代表最终的意思，可以修饰成员方法、成员变量、类

  2. final修饰类、方法、变量的效果

    final修饰类:该类不能被继承(不能有子类，但是可以有父类)

    final修饰方法:该方法不能被重写

    final修饰变量:表明该变量是一个常量，不能再次赋值

  3. final 修饰基本数据类型变量 final 修饰指的是基本类型的数据值不能发生改变

  4. final 修饰引用数据类型变量 final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的

  5. public static void main(String[] args){
    final Student s = new Student(23);
   s = new Student(24);  // 错误  
  s.setAge(24);  // 正确   
}

3.关键字static

  1. static的概念

    static关键字是静态的意思，可以修饰成员方法、成员变量

  2. static修饰的特点

    ①被类的所有对象共享，这也是我们判断是否使用静态关键字的条件

    ②可以通过类名调用，也可以通过对象名调用

  3. static的访问特点(静态成员方法只能访问静态成员)

    ①非静态的成员方法

    • 能访问静态的成员变量

    • 能访问非静态的成员变量

    • 能访问静态的成员方法

    • 能访问非静态的成员方法

    ②静态的成员方法

    • 能访问静态的成员变量

    • 能访问静态的成员方法

  4. 示例代码

public class test {
    public static void main(String[] args) {
        Student.company = "JD*HW" ;
​
        Student s1 = new Student();
        s1.setName("小石");
        s1.setAge("20");
        s1.show();//小石-20-JD*HW
        Student s2 = new Student();
        s2.setName("大石");
        s2.setAge("20");
        s2.show();//大石-20-JD*HW
    }
}
class Student{
    public String name;
    public String age;
    public static String company;
    public void show(){
        System.out.println(name+"-"+age+"-"+company);
    }
​
    public Student() {
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getAge() {
        return age;
    }
​
    public void setAge(String age) {
        this.age = age;
    }
​
    public static String getCompany() {
        return company;
    }
​
    public static void setCompany(String company) {
        Student.company = company;
    }
}


这篇关于Java面向对象的三大特征及关键字的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！


相关编程文章

更多>
本站官方QQ
官方QQ:
23002807

沪ICP备2023033072号-1

     

扫一扫关注最新编程教程