JAVA第八课-优快云博客

本文链接：https://blog.youkuaiyun.com/aaaghvhg/article/details/148667612

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

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

2.基础知识(0/5）

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

有补充或者有错误我会在评论区里发。
———————————————————————————————————————————
面向对象
面向对象的思想

面向过程：将问题拆分为步骤：第一步，第二步，...直到将问题解决....
面向对象：想将程序中所用到的对象找出，作为整体进行应用，利用各对象之间的关系，进行解决问题。

基础知识1：

一.对象

对象：复杂的客观事物，在Java程序中的一种表现形式。(一切客观事物都是对象)
对象的组成：
（1）属性：代表对象有什么特征/特点,对象的静态部分，用变量来表示
（2）方法：代表对象有什么功能/行为,对象的动态部分，用函数/方法表示。
计算中对象的描述：计算中用类对一组对象进行描述，该对象有哪些属性和方法。
类和对象的关系：
（1）类是对象的模板
（2）对象是类的实例 (基于一个类可以创建 n 个对象)

二.对象的创建 （重点！！！！）

语法(你输入的)：类名对象名 = new 类名();
对象的使用：
（1）对属性赋值的语法： 对象名.属性名 = 值; 调用属性：对象名.属性名
（2）调用对象的方法的语法(根据实参找你写的对象的对应的方法)：对象名.方法名(实参);

三.类的组成

属性：描述对象有哪些特征、特点
（1）属性：又称为成员变量
（2）位置：定义在类以内，方法以外
（3）语法（就是你输入的）：
数据类型变量名;
数据类型变量名 = 值; //声明的同时并赋值
注意：声明和赋值需要一起进行
class A{

int value ;

value = 20 ; //这是错误的写法，初始化必须和声明一起进行

}

(4)注意：开发时，类中定义属性，只需定义程序功能所关注的那部分属性即可。
(5)成员变量具有默认值，默认值和数组相同，具体情况如下：
整数 0

小数 0.0

字符空字符('\u0000')

布尔 false

引用 null

（6）成员变量的作用范围：至少在本类中有效。

照猫画虎1：

package demo;

public class TestStudent{
	public static void main(String[]args){
	//创建对象
    Student s=new Student();
    //为属性赋值
    s.name="大美丽";
    s.age=37;
    s.sex='男';
    s.score=100.0;
    //使用属性	
    System.out.println(s.name+"-"+s.age+"-"+s.score+"-"+s.sex);
	s.study();
	//自己完成第二个学生对象的创建，信息为：自己的名字-自己的年龄-性别-成绩，打印，并调用sayHello方法 	
	
	
	Student c=new Student();
	
	c.name="大大美丽";
    c.age=19;
    c.sex='女';
    c.score=100.0;	
		
	System.out.println(c.name+"-"+c.age+"-"+c.score+"-"+c.sex);
	c.sayHello();	
	}
}

//
//学生类：描述学生对象有那哪些属性和哪些方法
class Student{
      //1.属性：代表该对象有哪些特点，姓名，性别，年龄，成绩，班级，电话，身份证，脸型（实际上根据需求留下关注的内容即可）
	  /*
	    属性：成员变量，定义在类内，方法之外
	    定义：数据类型，变量名；
	  
	  */
	String name;
    int age;
    char sex;
    double score;
	  //2.方法：代表该对象有哪些功能    学习，表达（也是留下关注的部分即可）
      //方法：等价于之前的函数，定义在类以内，方法之外，不加static
	  
		
		
		public void study(){
		 System.out.println("学习使我快乐..呵呵"); 
		  
	  }
	  
	  	public void sayHello(){
		 System.out.println("大家好..."); 
		  
	  }
	  
	  
	  }

输出：
大美丽-37-100.0-男
学习使我快乐..呵呵
大大美丽-19-100.0-女
大家好...

基础知识2：

方法：描述对象有哪些功能、行为。
（1）方法又称为成员方法。
（2）位置：定义在类以内，其他方法以外。
（3）语法：
a.函数：public static 返回值类型函数名(形参列表){

// 函数体(函数实现部分)

}

b.方法：public 返回值类型方法名(形参列表){

// 方法体(方法的实现部分)

}

注意：看上方的区别，方法定义时，不需要添加 static 。

（4）方法的定义：
a.方法的声明：代表对象能做什么

方法的修饰符返回值类型方法名 (形参列表)异常
注意：一个方法可以有多个修饰符，并且多个修饰符之间没有先后顺序。

方法的修饰符：

1.访问修饰符（控制可见性）public

方法可以被任何其他类访问。protected

方法允许同一包内的类及其他包中的子类访问。private

方法仅能在定义它的类内部访问。默认（无修饰符，即包私有）

方法只能被同一包内的类访问。

2. 非访问修饰符（控制行为）static

方法属于类而非实例，可直接通过类名调用。final

方法不能被子类重写（覆盖）。abstract

方法没有实现体，必须在抽象类中定义，由子类实现。synchronized

方法在同一时间只能被一个线程访问，用于多线程同步。native

方法通过本地代码（如C/C++）实现，通常与JNI（Java Native Interface）结合使用。strictfp

3. 特殊场景修饰符
default（仅接口中使用）

（以上修饰符以后慢慢了解）

b. 方法的实现：代表对象具体怎么做，如何实现声明的功能

{ // 方法具体如何实现对应的功能 }

(重点！！！)构造方法：
(1)构造方法：是类中一种特殊的方法，也被称为构造器。
(2)特点：
a.构造方法的方法名必须和类名完全一致
b.构造方法没有返回值 (连 void 没有) 语法：修饰符类名(形式参数){}
c.构造方法允许重载
d.构造方法不允许手动调用
(3)注意：
a.构造方法不允许手动调用，在创建对象时，JVM根据指定实际参数决定调用哪一个构造方法完成对象的创建，一个对象的创建只能调用一次构造方法
b.如果一个类中没有定义任何构造方法，则JVM会自动默认添加一个公开无参数的构造方法；

如果类中定义了任何的有参数的构造方法，则JVM不再提供默认的公开无参数的构造方法。

（4）构造方法的作用：通常用于给属性赋值。
（5）开发建议：定义一个类时，通常提供无参数的构造方法和有参数的构造方法，没有特殊说明的情况下，有参数的构造方法的参数个数取决于属性的个数和类型。

照猫画虎2：

package demo;

public class TestDog{
	public static void main(String[]args){
		Dog d=new Dog("旺财",2,"白色");
		System.out.println(d.name+"-"+d.age+"-"+d.color);
		Dog d2=new Dog();
		d2.age=20;
		System.out.println(d.age);//2
	    System.out.println(d2.age);//20
		Dog d3;//声明引用
		d3=d;
		d3.color="花的";
		System.out.println(d.color);
	    System.out.println(d3.color);
		
	}
}
class Dog{
	//1.属性
	String name;
	int age=1;
	String color;
	
	
	
	//2.构造方法
    public Dog(){};
	public Dog(String name,int age,String color){
		this.name=name;
		this.age=age;
		this.color=color;
		
	}
	
	//3.成员方法
    public void shout(){
	System.out.println("狗叫。。。旺旺");	
		
	} 
	
	
	
	
}

输出：
旺财-2-白色
2
20
花的
花的

照猫画虎3：

package demo;

public class TestDog2{
   public static void main(String[] args){
    getDog( new Dog("豆豆",1,"黑色"));

	Dog d= new Dog("花花",5,"白色");
    getDog (d);
	
    Dog n=testDog();
    System.out.println(n.name+"-"+n.age+"-"+n.color);
    System.out.println("=========================");
    Dog[] ds= new Dog[3];
    ds[0]= new Dog("贝贝",3,"黑色");
    ds[1]= new Dog("小黑",2,"黑色");
    ds[2]= new Dog("小白",2,"白色");
	for(int i=0;i<ds.length;i++){
    System.out.println(ds[i].name+"_"+ds[i].age+"-"+ds[i].color);
    }

	
    System.out.println("=========================");
	for(int i=0;i<ds.length;i++){
	if(ds[1].age==2){
    System.out.println(ds[i].name+"_"+ds[i].age+"-"+ds[i].color);
     
    }	
    }
    }
   public static void getDog(Dog n){
        System.out.println(n.name+"_"+n.age+"-"+n.color);
   
   
   }
   public static Dog testDog(){
   //return new Dog();
   Dog d= new Dog("大黄",3,"黄色");
   return d;
   
}
}

输出：
豆豆_1-黑色
花花_5-白色
大黄-3-黄色
=========================
贝贝_3-黑色
小黑_2-黑色
小白_2-白色
=========================
贝贝_3-黑色
小黑_2-黑色
小白_2-白色

基础知识3：

（重点！！！！！）方法的重载(overload)
1.概念：在一个类中定义多个相同名字，但是形参列表不同的方法。
2.要求：
（1）方法名相同
（2）形参列表不同(个数、类型、顺序)
（3）返回值类型、修饰符、异常没有要求

注意：只是形参名字不同，不能构成方法重载，而是要形参列表不同！！！

以照猫画虎4为例方法的重载的代码：

public void ma(){
       System.out.println("无参数的");
   }

   public void ma(String str){
       System.out.println("String参数的");
   }


   public void ma(int a,int b){
       System.out.println("2个参数的");
   }

3.使用：编译器会根据调用时指定实际参数，决定具体调用哪一个方法。（就是你调用时用的什么实际参数，你不是方法重载了吗就会有相同方法名不同形参列表的方法，它就在你的方法名相同的代码中找到与你要调用所写的实际参数对应的方法（就是用实际参数调用你想要的方法））

指定时先精确匹配，精确匹配不成功，再就近向上匹配，如果还不成功，则编译报错。
注意：方法重载时，避免调用发生匹配混淆现象。

好处：使代码程序更加的通用和灵活。

照猫画虎4：

package demo;

public class TestMyClass{
	public static void main(String[]args){
		
	MyClass mc = new MyClass();
    mc.ma(23); 	
		
		
	}
}

//方法的重载，多个方法，区别在参数不同
//方法的重载：方法名相同，但是参数列表不同（个数，类型，顺序有一个不同就为不同）
class MyClass{
	public void ma(int a){
		System.out.println("一个参数的int的方法");
	}
	
	//public void ma(int m){}   //注意：仅仅参数的名字不同，不能构成方法的重载
	
	
	
	public void ma(){
		System.out.println("无参数的");
	}
	
	public void ma(String str){
		System.out.println("String参数的");
	}
	
	
	public void ma(int a,int b){
		System.out.println("2个参数的");
	}
	
	
	
	
	
	
}

输出：
一个参数的int的方法

基础知识4：

一.（重点！！！！！！！！！！！！！！！！！）命名冲突：在一个类中不能有重名的属性(成员变量)，但是成员变量可以和局部变量命名冲突，一旦命名冲突，在定义局部变量的方法中，优先使用局部变量。

成员变量和局部变量的区别：

局部变量 成员变量
位置：定义方法内定义在类以内，方法以外

默认值：没有默认值，先赋值后使用具有默认值

作用范围：从定义开始，到定义它的代码块结束至少在本类中有效

命名冲突：在重合的作用范围内，不允许命名冲突可以和局部变量命名冲突冲突时，在定义局部变量的方法中，优先使用局部变量

二.this 的应用( this. 和 this() )

第一种应用： this.
（1）（非语法，只是代表意义）this 代表当前对象，类似于 '我'
（2）this. 用在类中的成员方法或是构造方法中，代表调用当前对象的属性或是成员方法
（3）语法：
this.属性名：代表调用当前对象的属性
this.成员方法名(实参); 代表调用当前对象的成员方法
（4）注意：this. 通常可以省略，但是一旦成员变量和局部变量命名冲突时，需要用 this. 来区分成员变量
第二种应用：this()
（1）（非语法，只是代表意义）this() 用在类中构造方法中，代表调用本类的其他构造方法
（2）语法：
this() : 代表调用本类无参数的构造方法
this(实参)：代表调用本类有参数的构造方法

（3）this()/this(实参) 必须定义在构造方法中第一行有效语句
（4）this()/this(实参) 使用时避免出现递归调用/回环调用，所以一个类中构造方法中的第一行不能都使用this()/ this(实参)

照猫画虎5：

package demo;

public class TestStudent2{
	public static void main(String[]args){
		
	Student s = new Student("大美丽",18,99.0);//创建对象时，调用构造方法（根据传递的参数）
	System.out.println(s.name+"-"+s.age+"-"+s.score);//通过对象访问：成员变量
	s.study();
	
	}
}

class Student{
	//1.属性
	String name;
	int age;
	double score;
	
	
	//2.构造方法：构造方法的方法名必须和类名一致，没有返回值类型；允许重载
	public Student(){}
	public Student(String s){
		System.out.println("一个参数的构造方法");
	}
	
		public Student(String name,int age,double score){// s="王贺"   a=18   d=99.0   形参：方法内部的局部变量                
		//System.out.println("三个参数的构造方法。。。");
		//将局部变量中的数据赋值给成员变量
		this();
		//成员变量=局部变量
		this.name = name;
		this.age = age;
		this.score = score;
		
	}
	//3.成员方法
	public void study(){
		int age =100;//局部变量
		System.out.println("好好学习。。。");
        System.out.println(this.age);//访问当前对象的属性/成员变量
		System.out.println(age);//局部变量
		
	}
}

输出：
大美丽-18-99.0
好好学习。。。
18
100（明明上面有99.0，但是为什么却是study方法中的100，它没有指定是要成员变量还是局部变量，那么以就近原则为基准，离System.out.println(age);这个代码最近的，就是在同一个空间（study方法）的int age =100;，所以age为100）