JAVA第九课

已于 2025-06-16 20:43:48 修改
阅读量945 收藏 17
点赞数 25
CC 4.0 BY-SA版权
文章标签： java python 开发语言
于 2025-06-16 19:59:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/aaaghvhg/article/details/148672616

跟日记本一起学JAVA！相信你可以的，加油~

本课闯关内容：1.照猫画虎（0/9）                                                                                              

                         2.基础知识(0/6...）

                      这里的基础知识的编号与照猫画虎的编号不是对应的，而是上面的基础知识对应着下面相邻的照猫画虎代码。

                      有补充或者有错误我会在评论区里发或...
———————————————————————————————————————————

基础知识1：

面向对象的三大特性（封装、继承、多态）             

 

一、封装                                                              

  1. 修饰符：private ,代表私有的，被private 修饰的内容只能在本类中使用。             
                   public ,代表公开的，公共的
  2. 封装的要求：
    （1）属性私有化：属性被 private修饰
    （2）     为私有属性提供公开的get和set方法

             a.get 方法（语法）：获取私有化属性的值

                             public 数据类型   get属性名

                 (){    return  this.属性名;

                          }

           注意：返回值的数据类型取决于 获取属性的数据类型

                      方法名 ：  get + 属性名  （首字母大写）

                   b.set 方法（语法）：为私有化属性赋值

                                      public  void  set属性名(数据类型  变量名){    

                               this.属性名 = 变量名;

               }

              注意：形式参数的数据类型取决于  赋值的属性的数据类型

                         方法名： set + 属性名  -->首字母大写

         3.使用:
        （1）获取私有化的属性值：通过 get方法
        （2）为私有化的属性赋值：通过 set方法



照猫画虎1：
 

package demo;
public class Test{
	public static void main(String[]args){
	Student s = new Student();
	s.setName("大美丽");
	s.setAge(35);
	s.setScore(99.0);
	System.out.println(s.getName()+"-"+s.getAge()+"-"+s.getScore());	
		
	}
}


class Student{
	//属性:成员变量
	private String name;
	private int age;
	private double score;
	
	//构造方法
	public Student(){}
    public Student(String name, int age, double score){
		this.name =name;
		this.age =age;
		this.score =score;
	
		
	}	
	//get方法：
	public String getName(){
		return name;
	}
	//set方法：
	public void setName(String name){
		this.name =name;
		
	}
	public void setScore(double score){                                                              
		
		if(score>=0&&score<=100){
			this.score =score;
		}else{
			System.out.println("数据不合法...");
		}
	}

    //出口：获取私有化的属性值--get方法	
	public double getScore(){
		return score;
	}
	
	
	
    //入口：为私有化的属性赋值--set方法
    public void setAge(int age){
		//检测数据的有效性
		if(age>=0&&age<=160){
			this.age =age;
		}else{
			System.out.println("数据不合法...");
		}
	}

    //出口：获取私有化的属性值--get方法	
	public int getAge(){
		return age;
	}
	
	//成员方法
	public void study(){
		System.out.println("好好学习....");
		
	}
		
}

输出：大美丽-35-99.0



照猫画虎2：
 

package demo;

class book{
	private String title;
	private int pageNum;
	
	public book(){}
    public book(String title, int pageNum){
		this.title =title;
		this.pageNum =pageNum;
		
	}	
	
	public void setPageNum(int pageNum){                                                              
		
		if(pageNum>=200){
			this.pageNum =pageNum;
		}else{
			System.out.println("错误信息");
		}
	}

    
	public int getPageNum(){
		return pageNum;
	}
    public String getTitle(){
		return title;
	}	
	//set方法：
	public void setTitle(String title){
		this.title =title;
		
	}
	
	
	
	
}




public class Test1{
	public static void main(String[]args){
	book s = new book();
	s.setTitle("美丽的小岛");
	s.setPageNum(200);
	System.out.println(s.getTitle()+"-"+s.getPageNum());	
	          
	
	
	}

}

输出：美丽的小岛-200

基础知识2：

二、继承                                                              

      

1. 概念：

                水杯       是一种     容器                  
                铅笔       是一种       笔               
                 狗          是一种     动物

                  A            is - a         B

                  A             继承         B

(1) 继承 体现的类与类之间的 一种  "is - a"关系

               A      is  a        B

               A      继承       B

               A    extends    B

             子类                父类

 

        语法：  class 子类名  extends 父类名{} 

（2）继承是一种机制，通过继承可以让子类使用父类中的属性和方法

（3）开发时不能强制使用 继承(extends)，继承机制本身存在一种 "is-a"关系，不能人为、刻意的创造使用。

2.继承的好处：提高代码的可复用性、可扩展性。

3.方法的覆盖(override)（又称为方法的 重写）
(1)概念：在子类中定义和父类同名的方法。(发生在父子类之间)
(2)覆盖的要求：

a.子类的访问修饰符  和 父类相同或是 比父类更宽
b.子类的 方法名、形参列表、返回值类型 和  父类 相同

（3）使用：一旦子类覆盖了父类中方法，子类覆盖后的方法优先被使用(用子类型的引用调用)。
（4）注意：

a.如果 子类的方法名、返回值类型和父类相同，但是形式参数列表不同，编译通过，运行通过。--->重载
b.如果 子类的方法名、形参列表和父类相同，但是返回值类型不同，编译报错。

 

     写出 方法 覆盖  和  方法重载  各自特点。

     写出  override 和  overload 的 各自特点。

（5）应用场景：当子类从父类继承的方法不足以满足自身需求时，可以将继承到方法进行覆盖。

4.父类中属性和方法是将每一个子类的共性进行提取，决定父类中属性和方法。  

             (1)父类中信息是 一般的、抽象的

             (2) 子类中信息是特殊的、具体的

5.Java继承的特点：Java中的类之间是单继承关系，一个类只能有一个直接的父类，但是可以有多个间接的父类(多级继承)

         注意：Java中类之间的单继承关系，体现Java语言的简单性的特点。


6.子类可以从父类中继承哪些内容？构造方法、属性和成员方法来思考。
（1）构造方法不能被子类继承   
               
          a.构造方法的方法名必须和类名一样，子类和父类各有不同类名，所以子类继承父类的构造方法不满足构造方法的语法要求，所以不能继承
          b.子类的属性 和方法要比父类更复杂，所以子类的构造方法需要完成更多的赋值内容，所以父类的构造方法不满足子类构造需求，子类需要定义自身构造方法。

(2)属性和成员方法取决于访问修饰符(访问权限)   
a.Java中的4个访问修饰符

                           

                                     本类   同包(同包子类+非子类)  不同包的子类  其他(不同的非子类)            

private(私有的)：             ok

default(默认)：                 ok            ok                                                   

protected(受保护的)：      ok            ok                                  ok                                 

public(公开的、公共的)： ok            ok                                  ok                      ok

b.修饰符可以修饰符的内容：

(1)4个访问修饰符都可以用于修饰符属性、成员方法、构造方法
(2)public 和 default 可以用于修饰类

c.访问修饰符修饰属性和成员方法的继承性如下：          

private (私有的)    不能被继承          
default(默认的)     同包下的子类可以被继承          
protected(受保护的)：可以被子类继承的 (同包下的子类+不同下子类)         
public (公开的)  ： 可以被继承

7.创建对象的过程：继承        (先完成父类对象的创建，再完成子类对象的创建)     【理解】
（1）分配空间：子类+所有的父类空间    --->给属性赋默认值
（2）递归的创建父类对象：

             a. 初始化父类的属性：父类属性第二次赋值机会

             b.执行父类的构造方法：父类属性第三次赋值的机会

（3）完成子类对象的创建：
             a.初始化子类的属性：子类属性第二次赋值的机会

             b.执行子类的构造方法：子类属性第三次赋值的机会



照猫画虎3：
 

package demo;

public class TestAnimal{
	public static void main(String[]args){
	Dog d =new Dog();
    d.name ="大黄";
    d.color ="黄色";
    System.out.println(d.name+"-"+d.color);
    d.sleep();
    d.eat();
    d.shout();
    Cat c = new Cat();
	c.name = "小花花";
	System.out.println(c.name);
	c.sleep();
	
	}
	
	
}

//动物->父类
class Animal{
	
	String name;
	public void eat(){
		System.out.println("Animal...eat..");
		
	}
	
	public void sleep(){
		System.out.println("Animal..sleep");		
	}
}

//狗:是一种动物is-a的关系，狗和动物之间具有继承关系，狗继承动物->子类
class Dog extends Animal{
	String color;//毛色
	public void shout(){
		System.out.println("狗叫..旺旺");
	}
    //方法的覆盖(override)->方法的重写
	public void eat(){
		System.out.println("狗吃骨头...");
	}

	
}
//猫：是一种动物
class Cat extends Animal{}
//老虎：是一种动物
class Tiger extends Animal{}


输出：
大黄-黄色
Animal..sleep
狗吃骨头...
狗叫..旺旺
小花花
Animal..sleep

基础知识3：

三.多态                                                                    

  1. 概念：
    （1）多态：父类型的引用 指向 子类型对象。
    语法： 父类类名 引用名  = new 子类类名(实参);                                  
              //        引用                                 对象                                
              //   父类型                             子类型                                                                                           //   主观类型                          实际类型

    （2）用父类型的引用调用属性或是成员方法，只能调用父类中定义的属性和方法。(编译的时候检测)
      (3)     运行的时候，JVM会自动的检测子类是否覆盖了父类中方法，如果子类覆盖父类中方法，则执行子类覆盖后的方法，否则，直接执行的是父类中方法。




    2.引用之间的转换：
    （1）父类型的引用 赋值 给  子类型的引用  ，通过强制类型转换        
                 
                      大类型                         小类型

               a.语法： 子类类名 引用名  = (子类类名)父类型的引用名;
               
               b.案例：    Animal  a= new Dog();     

                                 Dog d = (Dog)a;        


                    c.结果：将父类型引用 通过强制类型转换 赋值给子类型的引用，编译一定通过,运行分为以下两种情况：
i.如果 实际存储对象类型 和 要转换的类型一致，则编译通过，运行也通过。

                           Animal  a= new Dog();              

                               Dog d = (Dog)a;     


ii.如果 实际存储对象类型和要转换的类型不一致，则编译通过，运行报错，错误如下(cmd中出现的)：                             java.lang.ClassCastException(类型转换异常)                        
例如：
            Animal a = new Cat(); // 实际存储对象类型是 ： Cat                             
                Dog d = (Dog)a;   // 要转换的类型  Dog        

注意：引用中实际存储的对象类型不变。

照猫画虎4：

package demo;

public class TestAnimal{
	public static void main(String[]args){
	//1.多态：父类型的引用存储子类型的对象	
	Animal a =new Dog();
	//引用        对象
	//父类型      子类型
	//2.使用父类型的引用调用属性和方法，只能调用父类中定义的属性和方法
	a.eat();
	a.sleep();
	//3.如果子类覆盖了父类中的属性和方法，则优先使用子类覆盖后的方法
	
	Dog d =(Dog)a;//父类型的引用赋值给子类型的引用时，需要强制类型转换
	d.shout();
	
	//Dog d2 =new Dog();
	//Animal a2 =d2;

    //Person p=(Person);	
	}
}


class Animal{
	public void eat(){
		System.out.println("Animal...eat..");
		
	}
	public void sleep(){
		System.out.println("Aniaml...sleep..");
	}
}


class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头...");
	}
    public void shout(){
		System.out.println("狗叫..");
	}
	
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫爱吃鱼");
	}
}

class Tiger extends Animal{}

输出：

狗吃骨头...
Aniaml...sleep..
狗叫..
 

基础知识4：
 

1.如何避免类型转换异常( java.lang.ClassCastException)？
（1）利用 instanceof关键字避免  类型转换异常。
（2）语法：引用名  instanceof  类名
（3）作用：将引用中存储的实际对象类型  和  instanceof后面的类型相比较，如果实际对象类型兼                   容后面的类型，结果-true,不兼容-结果为false.

应用场景：父类型的引用利用强制类型转换为子类型时，可以利用    instanceof判断。

2.子类型 的引用  赋值  父类型的引用  ，可以直接赋值   --->多态        
            小类型                       大类型

(1)语法： 父类类名 引用名  =  子类型的引用名;
(2)案例：              Dog d = new Dog();

                         Animal a = d;

3.不存在继承关系的双方，不允许转换，强制类型转换也不能通过，编译直接报错。

             Animal a = new Dog();

             Person p = (Person)a;  // 编译报错

照猫画虎5：

package demo;

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

	    Animal a =new Cat();
	
	    System.out.println(a instanceof Dog);//t
	    System.out.println(a instanceof Cat);//f
	    System.out.println(a instanceof Animal);//t
	    if(a instanceof Cat){
		    Cat c = (Cat)a;
		    c.eat();
	    }else{
		    System.out.println("类型不匹配，不能转换！！！");
	    }
	}
}


class Animal{
	public void eat(){
		System.out.println("Animal...eat..");
		
	}
	public void sleep(){
		System.out.println("Aniaml...sleep..");
	}
}


class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头...");
	}
    public void shout(){
		System.out.println("狗叫..");
	}
	
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫爱吃鱼");
	}
}

class Tiger extends Animal{}


输出：
false
true
true
猫爱吃鱼

基础知识5：

  1. 多态的实际开发应用
    （1）多态用在数组上：本类型+所有的子类型的对象都可以作为数组元素进行存储。
    （2）多态用在形式参数上：本类型+所有子类型的对象都可以作为实际参数进行传递。
    （3）多态用在返回值上：本类型+所有的子类型的对象都可以作为返回值返回。
  2. 多态体现的好处
    （1）屏蔽不同子类之间差异性，进行统一管理
    （2）让程序更加灵活和通用

 

照猫画虎6：

package demo;

public class TestAnimal3{
	public static void main(String[]args){
    getAnimal (new Dog());
	Dog d = new Dog();
	getAnimal(d);
	getAnimal(new Cat());
	
    Animal a=testAnimal();
	a.eat();
	   
	}
	//多态应用返回值上：本类型+子类型的对象/引用都可以作为返回值进行返回
	public static Animal testAnimal(){
		return new Dog();
	}
	//多态应用返回值上：本类型+子类型的对象/引用都可以作为参数进行传递
	public static void getAnimal(Animal n){
		n.eat();
	}
	
}


class Animal{
	public void eat(){
		System.out.println("Animal...eat..");
		
	}
	public void sleep(){
		System.out.println("Aniaml...sleep..");
	}
}


class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头...");
	}
    public void shout(){
		System.out.println("狗叫..");
	}
	
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫爱吃鱼");
	}
}

class Tiger extends Animal{}

输出：
狗吃骨头...
狗吃骨头...
猫爱吃鱼
狗吃骨头...

照猫画虎7：

package demo;

public class TestAnimal4{
	public static void main(String[]args){
        Animal[] as =new Animal[5];
		as[0]=new Dog();
		as[1]=new Cat();
		as[2]=new Dog();
		as[3]=new Tiger();
		as[4]=new Cat();
	    for(int i=0;i<as.length;i++){
			as[i].eat();
		}
		//统计数组中Cat的个数
		int count =0;
		for(int i=0;i<as.length;i++){
			if(as[i] instanceof Cat){
				count++;
			}
		}
		System.out.println("数组中的猫个数为："+count);
		
	}
	
}


class Animal{
	public void eat(){
		System.out.println("Animal...eat..");
		
	}
	public void sleep(){
		System.out.println("Aniaml...sleep..");
	}
}


class Dog extends Animal{
	public void eat(){
		System.out.println("狗吃骨头...");
	}
    public void shout(){
		System.out.println("狗叫..");
	}
	
}

class Cat extends Animal{
	public void eat(){
		System.out.println("猫爱吃鱼");
	}
}

class Tiger extends Animal{}


输出：

狗吃骨头...
猫爱吃鱼
狗吃骨头...
Animal...eat..
猫爱吃鱼
数组中的猫个数为：2
 

基础知识6：

super的应用: super()/super.       【面试+开发重点】
一.第一种应用：

      1.super() /super(实参) ：用在子类的构造方法中，指示创建子类对象时，JVM先去完成父类对象对象创建时，调用父类哪一个构造方法         
      2.调用的语法：
                                    super(): 调用父类无参数的构造方法            
                                    super(实参)：调用父类有参数的构造方法

注意：     (1)super()/super(实参) 必须定义在构造方法中第一行有效语句；

                (2)子类的构造方法方法第一行如果没有 super()/super(实参)/   ....的应用，则JVM默认添加super() ;

                (3)this()/this(实参)  和 super()/super(实参) 不能同时定义在一个构造方法中

                (4)如果子类的构造方法的第一行语句为 this()/this(实参)，则JVM完成父类创建时不在当前的子类的构造方法第一行语句查找 super()/super(实参) ，而是转向 this()/this(实参)指向的构造方法的第一行查找super()/super(实参)。     

                

二.第二种应用：

1.super. 用在子类的构造方法或是成员方法中  ，代表调用当前父类对象属性和成员方法
2.语法：
                    super.属性名    ：  调用父类的属性
                    super.成员方法： 调用父类的成员方法



总结：   当前JVM默认添加（就是你不用写的代码，它自己默认添加）的代码？

1.在一个类的成员方法中访问本类的其他成员方法或是 属性，默认 添加 this.
2.如果一个类中没有定义构造方法，则JVM默认添加公开、无参数的构造方法
3.如果子类的构造方法第一行没有使用 this()/this(实参) 或是 super(实参) ，则JVM默认在构造方法第一行添加 super();
4.java.lang 包中类如果被使用，则JVM默认添加 import java.lang. 类名;   语句
 

照猫画虎8：

package demo;

public class TestMyClass{
	public static void main(String[]args){
	B b=new B(5);
	b.test();

	}
	
	
}

class A{
	int m=90;
	public A(){
		System.out.println("无参数的构造方法...");
	}
    public A(int n){
		System.out.println("有参数的构造方法..A(int).");
	}	
	
	public void ma(){
		System.out.println("父类中的方法ma");
	}
	
}


class B extends A{
	int m=80;
	public B(){
		//super()默认
		System.out.println("无参数的构造方法B()");
	}
	public B(int n){
		super(n);
		System.out.println("有参数的构造方法B(int n)..");
	}
    public void ma(){
		System.out.println("子类中的方法ma...");
		
	}
	public void test(){
		int m=70;
		System.out.println("m="+m);//70
		System.out.println("this.m="+this.m);//80
		System.out.println("super.m="+super.m);//90
		

	    ma();
        super.ma();		
		
	}
	
}


输出：
有参数的构造方法..A(int).
有参数的构造方法B(int n)..
m=70
this.m=80
super.m=90
子类中的方法ma...
父类中的方法ma
 

照猫画虎9：

package demo;

public class TestPerson{
	public static void main(String[]args){
	    Student s=new Student("大美丽",18,"中国");
		System.out.println(s.name+"-"+s.age+"-" +s.nation);

	}
}

class Person{
	String name;
	int age;
	String nation;//国籍
	
	public Person(){}
		public Person(String name,int age,String nation ){
			this.name =name;
			this.age =age;
			this.nation =nation;
			
		}
		public void work(){}
	}
	
	
class Student extends Person{
	public Student(){}
	public Student(String name,int age,String nation){
		super(name,age,nation);
	}
	public void work(){
		System.out.println("学习");
	}
	
}

输出：

大美丽-18-中国



跟我一步步学，慢慢走。
未完待续。。。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值