week_02_面向对象基础

序

接着上一周末尾讲的switch语句,第一天讲了循环语句switch,for,while语句的使用,穿插了死循环,for的嵌套, 跳转语句,引入方法,第二天重点,有返回值类型的定义方法和没有返回值类型的定义方法,引入数组;第三天重点冒泡排序,还有形式参数,引入面向对象,第四天定义面向对象,重点形式参数是引用类型还是基本类型,第五天构造方法,标准类的写法

1.循环语句(switch,for,死循环,while,do while)

switch

switch语句的格式上周已经讲的很清楚了,这周主要学习switch语句的使用,写switch语句的过程很复杂,但是一些题还是需要用到这个,比如说下面这个选择题

建一个选择题

/*
使用switch语句做一个选择题
键盘录入选择题选项(字符串)'A','B','C','D'
还需要用到强制类型转换.
*/
import java.util.Scanner ;//导包
 public class StudentDemo{
    public static void main(String[] args){
        System.out.println("哪一个不是海贼王的人物?") ;//先给出几个选项
        System.out.println("65 江户川柯南");
        System.out.println("66 蒙奇D路飞");
        System.out.println("67 娜美");
        System.out.println("68 文斯莫克山治");
        
        Scanner sc = new Scanner(System.in) ;//创建键盘录入对象
        System.out.println("请您输入数据:") ;//录入并提示
        int choice = sc.nextInt() ;
        char choiceNum = (char)choice;//强转
        
        switch(choiceNum){          //提供switch语句选择判断
            case 'A':
                System.out.println("答对了") ;
                break ;
            case 'B' :
                System.out.println("错误") ;
                break ;
            case 'C' :
                System.out.println("错误") ;
                break ;
            case 'D' :
                System.out.println("错误") ;
                break ;
            default:
                break ;
        }
    }
/*
D选项的break可以去掉,但是我们初学者一般不建议,在这里就要引入上周学的穿透,根据题目,可以实行穿透,
比如说季节问题,每三个月可以case下去,用一个break即可;
*/
switch(month){
		case 3:
		case 4:
		case 5:
			System.out.println("春季");
			break ;

for

for循环是个重点,for循环的面试题:水仙花数,算数字1-100之和,1-100的偶数\奇数之和,还有for循环的嵌套,百钱买百鸡问题,打印**问题.

水仙花数

/*
水仙花数:一个三位数(100-999),每个位上的立方等于这个数:a*3+b*3+c*3=abc;
*/
class Flower{
	public static void main(String[] args){
		
		for(int x = 100 ; x < 1000; x++){
			int ge = x % 10 ;//定义三个变量:分别获取每个位上的数据本身
			int shi = x / 10 % 10 ;
			int bai = x / 10 /10 % 10 ;
			if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)){
				System.out.println("水仙花数是:"+x) ;//获取水仙花
			}
		}
	}
}
/*
水仙花数还有一个统计,统计水仙花数出现了几次需要用到变量count
*/
if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
				System.out.println(x) ;
				//统计变量++
				count ++ ;
			}

求和(1-100的和,1-100偶数和,1-100奇数和)

/*
求和思想:
        1)第一个加数:从0开始,每一次求和的结果	(最终的结果变量)
		2)第二个加数:1,2...10:数据本身 (循环中的数据本身)	
*/
public class StudentDemo{
    public static void main(String[] args){
        int sum = 0;
        for(int x=1;x<=100;x++){
            sum += x;
        }
        System.out.println("1-100的和为:"+sum);
    }
}
//1-100的偶数之和就是加一个判断if语句,让x的值除以2余0就可以了
//奇数之和就是非一下偶数

百钱买百鸡(for循环嵌套)

/*
百钱买百鸡,100文钱,公鸡 5文一只,母鸡 3文一只,小鸡 一文钱三只
这里要用一个方法:穷举法
*/
class ChickenNumTest{
	public static void main(String[] args){
		for(int x = 0; x < 20 ; x ++ ){//穷举公鸡
			for(int y = 0 ; y < 33 ; y ++){//穷举母鸡
				int z = 100 - x - y ;//小鸡数量
				if((5*x+3*y+z/3)==100 && (z % 3 ==0) ){
					System.out.println("公鸡有:"+x+"只"+",母鸡有:"+y+"只"+",小鸡有:"+z+"只") ;
				}
			}
		}
	}
}

打印**,九九乘法表(for循环嵌套)

/*
打印4行5列的**,如果用传统方法,就是一行一行输出,代码雍容复杂,不建议使用,使用for循环的嵌套就明了
*/
for(int x = 0 ; x < 4 ; x++){ //外层循环:就是一个控制行数
			for(int y = 0 ; y < 5 ; y ++){//内层循环:控制列数
				System.out.print("*") ; //在同一行输出5个*
			}
			System.out.println() ;
/*
列数在变化的**,九九乘法表都使用for循环嵌套
*/
//列数在变化的**
for(int x = 0 ; x < 5 ; x ++){//5行5的列的*	
				for(int y = 0 ; y <=x ; y++){//变化的列数y
					System.out.print("*") ;
				}
				System.out.println() ;
			}
//九九乘法表
for(int x = 1 ; x <= 9 ; x ++){//行数
	for(int y = 1 ; y <= x ; y++) {//变化的列数y
		System.out.print(x+"*"+y+"="+(y*x)+"\t") ;		
	}
	System.out.println() ;

死循环

猜数字游戏

/*
一般在开发中使用,满足某个条件时,跳转死循环.break
针对数学运算操作的类产生一个随机数
*/
if(guessNumber>num){
				System.out.println("您要猜的数字大了...") ;
			}else if(guessNumber<num){
				System.out.println("您要猜的数字小了...") ;
			}else{
				System.out.println("恭喜您,第"+count+"次猜中了...") ;
				break ;//结束
			}

while

阶乘

/*
while:不明确循环次数,使用
*/
int jc = 1 ;
		int j = 1 ;
		while(j<=5) {
			jc*= j ;
			j++ ;
		}
		System.out.println("5的阶乘是:"+jc) ;

do while

do while求1-100和

/*
在开发中不建议使用,优先for,其次是while,最后是do while
*/
int sum = 0 ;
		int x = 1 ;
		do{
			sum += x ;
			x ++ ;
		}while(x<=100) ;
		//输出sum
		System.out.println("1-100之间的和是:"+sum) ;

2.跳转语句(break,return,continue)

break

/*
结束中断,结束循环(不能单独使用)在switch和循环中使用
*/
for(int x = 0 ; x < 10 ; x ++){ //x=0,x=1,x=2,x=3
			//判断
			if(x == 3){
				break ;
			}

continue

/*
继续, 在循环中使用,结束当前循环,立即进入下一次循环
*/
for(int x = 0 ; x < 10; x ++){//x=0 ,1,2,3,4
				if(x == 3){
					continue ;//跳出当前循环,立即下一次循环
				}

return

/*
很少单独使用,结合有具体返回值类型的方法使用!结束方法的;
*/
System.out.println("程序开始了....") ;
		for(int x = 0 ; x < 10 ; x ++){
			System.out.println("进入for循环了...") ;
			if(x==3){
				//break ;
				return ; //单独使用,return:结束方法的

3.方法

定义方法:
两个明确
1)明确返回值类型
2)明确参数类型以及参数个数

有具体返回值类型的方法的定义

调用方法的时候,不能和main方法嵌套,只能是平级关系.
只能赋值调用

键盘录入三个数据，比较三个数据中的最大值

import java.util.Scanner ;
class FunctionTest1{
	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请输入第一个数据:") ;
		int a = sc.nextInt() ;
		
		System.out.println("请输入第二个数据:") ;
		int b = sc.nextInt() ;
		
		System.out.println("请输入第三个数据:") ;
		int c = sc.nextInt() ;

		//调用获取三个数据最大值的方法
		int max  = getMax(a,b,c) ;
		System.out.println("三个数据中的最大值是:"+max) ;
		}
		public static int getMax(int a,int b,int c){//形式参数
			//if语句
			int max ;
			if(a>b){
				//判断a和 c
				if(a>c){
					max = a ;
				}else{
					max = c ;
				}
				
			}else{
				//判断b和c
				if(b>c){
					max = b ;
				}else{
					max = c ;
				}
			}
		return max ;	
	}
}

键盘录入两个个数据，判断数据是否相等

import java.util.Scanner ;
class FunctionTest1{
	public static void main(String[] args){
	//提示并录入数据
		System.out.println("请输入第一个数据:") ;
		int num1 = sc.nextInt() ;
		
		System.out.println("请输入第二个数据:") ;
		int num2 = sc.nextInt() ;
		
		//调用方法
		boolean flag = compare(num1,num2) ;
		System.out.println(flag) ;
		}
		public static boolean compare(int a,int b){//形式参数
		//三元运算符
		//boolean flag = (a==b)? true:false ;
		boolean flag = (a==b) ;
		return flag;
		}
	}

键盘录入两个数据，获取最大值

import java.util.Scanner ;
class FunctionTest1{
	public static void main(String[] args){
	    System.out.println("请输入第一个数据:") ;
		int x = sc.nextInt() ;
		
		System.out.println("请输入第二个数据:") ;
		int y = sc.nextInt() ;
		
		//调用: 方法(获取两个数据中的最大值)
		int result = getResult(x,y) ;
		System.out.println("result:"+result) ;
		
	}
	public static int getResult(int a,int b){
			//三元运算符/if
			int max = (a>b)? a: b;
			return max ;
	}
}

没有具体返回值类型的方法的定义

只能单独调用

改进4行5列*

/*
两个明确:
	1)明确返回值类型:没有具体返回值类型:使用void代替
	2)明确参数类型以及参数个数
*/
printStar(m,n) ;
public static void printStar(int m,int n){
		//4行5列的* 代码
		for(int x = 0 ;x <m ; x ++){
			for(int y = 0 ; y < n ; y ++){
				System.out.print("*") ;
			}
			System.out.println() ;
		}

n n乘法表

/*
定义方法:两个明确
			1)明确返回值类型: 没有具体返回值 void
			2)明确参数类型以及参数个数
					int  一个参数
*/
import java.util.Scanner ;
class FunctionTest{
	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并录入数据
		System.out.println("请您输入一个数据n(1-9):") ;
		int n = sc.nextInt() ;
		
		//调用方法
		printNN(n) ;
	}
public static void printNN(int n){
		//为了保证有数据:从1开始
		for(int x = 1; x <=n ;x ++){
			for(int y = 1; y <=x ; y ++){
				System.out.print(x+"*"+y+"="+(y*x)+"\t") ;
			}
			System.out.println() ;
		}
	}
}

方法重载

方法名相同,参数列表不同,与返回值无关!
目的:就是为了提高某个功能的扩展性

//了解方法重载,给出几组方法,要认得哪些方法是属于方法重载
a  public static void open(){} 
b  public static void open(int a){} 
c  static void open(int a,int b){} 带public :权限足够大
d  public static void open(double a,int b){} 
e  public static void open(int a,double d){}
f  public void open(int i,double d){} 
g  public static void OPEN(){} 
h  public static void open(int i,int j){}	  
//g不属于方法重载

形式参数问题

参数是基本数据类型

形式参数的改变不会影响实际参数!

参数是引用数据类型

String类型:特殊的引用类型:它作为形式参数,效果和基本数据类型一致!
形式参数的改变不影响实际参数(String本质就是常量)
如果形式参数是数组类型(除String类型外),
实际参数传递:传递数组对象 :形式参数的改变会直接影响实际参数

class Student{
	public void study(){
		System.out.println("Good Good Study ,Day Day Up!!") ;
	}
}
//定义一个StudentDemo类
class StudentDemo{
	//有一个method成员方法
	public void method(Student s){ //方法的形式参数是Student类型
		s.study() ;					
	}
}
//测试类
class StudentTest{
	public static void main(String[] args){
		//创建StudentDemo类对象
		StudentDemo sd = new StudentDemo() ;
		//先去创建学生对象
		Student stu = new Student() ;
		sd.method(stu) ;
	}
}

构造方法

1)构造方法名和类名一致
2)没有具体的返回值类型
3)连void都没有

有参构造/无参构造

/*
除非题目要求使用哪种构造方法,我们自己在做题时两种方法都写
*/
class Phone{
	private String brand ;
	private int price ;//价格
	private String color ;
	public Phone(){	
	}
	//提供了带参数构造方法
	//("锤子手机",1299,"黑色"
	public Phone(String brand,int price ,String color){//局部变量
		this.brand = brand ;
		this.price = price ;
		this.color = color ;
	}
	//提供setXXX()/getXXX()方法
	public void setBrand(String brand){
		this.brand = brand ;
	}
	public String getBrand(){
		return brand ;
	}
	//给价格赋值
	public void setPrice(int price){
		this.price = price ;
	}
	public int getPrice(){
		return price ;
	}
	
	//给颜色赋值
	public void setColor(String color){
		this.color = color ;
	}
	public String getColor(){
		return color ;
	}
	//其他成员方法(手机事物的行为)
}
//测试类
class ConstructorDemo2{
	public static void main(String[] args){
		//通过无参构造方法创建对象
		//方式1:无参构造方法+setXXX()/getXXX()
		Phone p = new Phone();//
		//setXXX()赋值
		p.setBrand("锤子手机") ;
		p.setPrice(1299) ;
		p.setColor("黑色") ;
		System.out.println("品牌:"+p.getBrand()+",价格:"+p.getPrice()+",颜色:"+p.getColor()) ;
		System.out.println(p) ;
		System.out.println("---------------------") ;
		//方式2:通过有参构造方法赋值 + 结合getXXX()获取内容
		Phone p2 = new Phone("锤子手机",1299,"黑色") ; 
		System.out.println("品牌:"+p2.getBrand()+",价格:"+p2.getPrice()+"颜色:"+p2.getColor()) ;
	}
}

4.数组

动态初始化

数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度] ;

/*
	创建两个数组,分别输出对象名称,以及元素内容(数组对象[角标值])
	分别给两个数组中的部分元素赋值(显示初始化),
	再次输出两个数组对象名称以及元素内容
*/
class ArrayDemo2{
	public static void main(String[] args){
		
		//动态初始化
		//创建第一个数组对象
		int[] arr = new int[2] ;//2个长度(角标:0,1)
		//创建第二个数组对象
		int[] arr2 = new int[3] ;//3个长度(角标0,1,2) 
		System.out.println(arr) ;
		System.out.println(arr2) ;
		System.out.println(arr[0]) ;
		System.out.println(arr[1]) ;
		System.out.println(arr2[0]) ;
		System.out.println(arr2[1]) ;
		System.out.println(arr2[2]) ;
		System.out.println("--------------------------------") ;
		//给部分元素内容赋值
		arr[1] = 100 ;
		arr2[0] = 50 ;
		arr2[2] = 30 ;
		System.out.println(arr) ;
		System.out.println(arr2) ;
		System.out.println(arr[0]) ;
		System.out.println(arr[1]) ;
		System.out.println(arr2[0]) ;
		System.out.println(arr2[1]) ;
		System.out.println(arr2[2]) ;
		System.out.println("-----------------------") ;
		arr2 = new int[2] ;
		System.out.println(arr2) ;
		
	}
}

静态初始化

数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3…} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3…} ;
简化格式:
数据类型[] 数组名称 = {元素1,元素2,元素3…} ;
数据类型 数组名称[] = {元素1,元素2,元素3…} ;

遍历

/*
将数组中的元素一一获取到并输出到控制台上
*/
public static void printArray2(int[] arr){
		//先输出一个左中括号 ,输出时不换行
		System.out.print("[") ;
		//遍历数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断:如果当前x :取到最大索引值 arr.length-1
			if(x==arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				//不是最后一个索引值,中间的元素 arr[x]+", " 不换行
				System.out.print(arr[x]+", ") ;
			}
		}

获取数组最大值\最小值

/*
获取数组中的最大值
		1)定义max变量:将数组的第一个元素赋值给他:默认最大值
		2)从角标1开始遍历其他元素
			在里面判断
			如果后面的元素都大于max
				将后面的元素赋值给max变量
		3)最终可以获取最大值	
获取数组中的最小值
		1)定义变量min :将数组的第一个元素赋值给min:默认最小值
		2)遍历其他元素
			判断:如果后面的元素都min小,
			将后面的元素赋值给min
		3)获取最小值	
*/
//最大值
class ArrayTest{
	public static void main(String[] args){
		//创建数组:静态初始化
		int[] arr = {69,13,56,87,24} ;
		//假设法:
		//定义一个max变量
		int max = arr[0] ;
		//从角标1开始遍历其他元素
		for(int x = 1; x < arr.length ; x ++){
			//获取到每一个元素了,判断
			if(arr[x] > max ){	
				//改变max 的值
				max = arr[x] ;
			}
		}
		//输出max
		System.out.println("数组中的最大值是:"+max) ;
		}
		public static int getMax(int[] arr){
		//假设思想:
		int max = arr[0] ;
		
		for(int x = 1 ; x < arr.length ; x ++){
			//判断
			if(arr[x] > max){
				max = arr[x] ;
			}
		}
		return max ;
	}
//最小值
class ArrayTest{
	public static void main(String[] args){
		//创建数组:静态初始化
		int[] arr = {69,13,56,87,24} ;
int min = getMin(arr) ;
		System.out.println("数组中的最小值是:"+min) ;	
	}
public static int getMin(int[] arr){
		//参照物
		int min = arr[0] ;
		//遍历其他元素
		for(int x = 1 ; x < arr.length ; x ++){
			//判断
			if(arr[x] < min){
				min = arr[x] ;
			}
		}
		return min ;
	}	

数组的元素逆序

/*
    将arr[0]元素和arr[arr.length-1-0]进行互换
	将arr[1]元素和arr[arr.length-1-1]进行互换
	...
	保证数组的长度/2
*/
class ArrayTest2{
	public static void main(String[] args){
		//创建一个数组:静态初始化
		int[] arr = {69,87,43,21,15} ;
		
		System.out.println("逆序前:") ;
		printArray(arr) ;
		System.out.println("---------------") ;
		
		System.out.println("逆序后:") ;
		reverse2(arr) ;
		//遍历逆序后的结果
		printArray(arr) ;
	}
	public static void reverse2(int[] arr){
		for(int start = 0 ,end = arr.length-1; start<=end ; start++,end--){
		//中间变量
		int temp = arr[start] ; 
		arr[start] = arr[end] ; 
			arr[end] = temp ;   
		}
	}
	public static void printArray(int[] arr){
		System.out.print("[") ;
		//遍历arr数组
		for(int x = 0 ; x < arr.length ; x ++){
			//获取元素并判断
			if(x==arr.length-1){
				System.out.println(arr[x]+"]") ;
			}else{
				//中间元素
				System.out.print(arr[x] +", ") ;
			}
		}
	}
}

数组的查表法

就是通过数组名称[索引值]来确定元素内容
数据类型[] 数组名称 = {元素1,元素2,…} ;

/*
键盘录入数据index(1-7) ,输出对应的星期
*/
import java.util.Scanner ;
class ArrayTest3{
	public static void main(String[] args){
		String[] strArray = {"星期一","星期二","星期三","星期四","星期五","星期六","星期日"} ;
		Scanner sc = new Scanner(System.in) ;
		//提示并录入数据
		System.out.println("请您输入一个数据index(0-6):") ;
		int index = sc.nextInt() ;
		System.out.println("您要查找的是:"+strArray[index]) ;		
	}
}

数组的基本查找法

在数组中查询某个元素第一次出现的索引值!

/*
针对数组没有要求:数组既可以有序的,也可以是无序的!
*/
class ArrayTest4{
	public static void main(String[] args){
		
		//创建数组,静态初始化
		int[] arr = {10,55,30,24,17} ;
	int index3 = getIndex2(arr,300) ;
		System.out.println(index3) ;
		int index4 = getIndex2(arr,17) ;
		System.out.println("你要找的元素的角标是:"+index4) ;
	}	
	public static int getIndex2(int[] arr,int target){
		//假设:找不到
		int index = -1 ; 
		
		//遍历arr数组
		for(int x = 0 ; x < arr.length ; x ++){
			//判断
			if(target==arr[x]){
				//就更改index的值
				index = x ; 
				break ;
			}
		}
		return index;
	}

冒泡排序

两两比较,较大的值往后放,第一次比较完毕,最大值出现在最大索引处
依次这样比较,可以得到排好序的数组!

for(int x = 0 ; x < 4 ; x ++){
			for(int y = 0 ;y < arr.length-1-x; y++){ 
				if(arr[y] > arr[y+1]){
					int temp = arr[y] ;
					arr[y] = arr[y+1] ;
					arr[y+1] = temp ;
				}
			}
		}

5.面向对象

思想特点

1)更符号我们生活中是思想行为习惯
2)让复杂的事情简单化
3)我们从执行者变成了指挥者

特征

封装
继承
多态

类与对象

类:能够描述现实世界真实事物的一组属性和行为的集合!

类的定义以及测试

手机事物

/*
	品牌,价格,颜色,内存的属性
	打电话,发短信,玩游戏,学习的行为
*/
class Phone{
	
	//成员变量
	String brand ; //品牌
	int price ; //价格
	String color ;//颜色
	int memory ; //内存
	
	//成员方法
	public void callPhone(String toName){ //参数toName:给谁打电话
		System.out.println("给"+toName+"打电话") ;
	}
	public void sendMsg(){
		System.out.println("可以使用手机发短信...") ;
	}
	public String playGame(String gameName){
		return "可以玩"+gameName+"游戏" ;
	}
	public void study(String className){
		
		System.out.println("学习"+className) ;
	}
}
class PhoneTest{
	public static void main(String[] args){
		//测试手机类
		//类名 对象名 = new 类名() ;
		Phone phone  = new Phone() ;
		System.out.println(phone) ;
		System.out.println("当前手机的品牌是:"+phone.brand+",价格是:"+phone.price+",手机颜色:"+phone.color+
		",手机内存是:"+phone.memory+"G");
		System.out.println("---------------------") ;
		//访问成员变量
		phone.brand = "华为mate30pro" ;
		phone.price = 6999 ;
		phone.color = "粉翠绿" ;
		phone.memory = 64;
		System.out.println("当前手机的品牌是:"+phone.brand+",价格是:"+phone.price+",手机颜色:"+phone.color+
		",手机内存是:"+phone.memory+"G");
		}
	}
class PhoneTest2{
	
	public static void main(String[] args){
		//创建两个手机类对象
		Phone p1 = new Phone() ;
		Phone p2 = new Phone();
		System.out.println(p1) ;
		System.out.println(p2) ;
		System.out.println(p1.brand+"---"+p1.price+"---"+p1.color+"---"+p1.memory) ;
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color+"---"+p2.memory) ;
		//赋值
		p1.brand = "iphone12" ;
		p1.price = 5999 ;
		p1.color = "玫瑰金" ;
		p1.memory=64 ;
		System.out.println(p1.brand+"---"+p1.price+"---"+p1.color+"---"+p1.memory) ;
		System.out.println("-----------------------------") ;
		p2.brand = "锤子手机" ;
		p2.price = 2999 ;
		p2.color = "天空灰" ;
		p2.memory= 32 ;
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color+"---"+p2.memory) ;
		//成员方法p1.方法名()  ;
//		p2.方法名() ;
	}
}
class PhoneTest3{
	
	public static void main(String[] args){
		//创建两个手机类对象
		//定义第三个Phone类型的变量 p3
		//将第一个手机类对象赋值给p3变量
		//再次通过p3.访问成员变量 ="赋值"
		//输出:第一个手机类对象中的所有属性
		
		Phone p1 = new Phone() ;
		p1.brand = "小米11" ;
		p1.price = 3999 ;
		p1.color = "黑色";
		p1.memory = 128;
		System.out.println(p1.brand+"---"+p1.price+"---"+p1.color+"---"+p1.memory) ;
		Phone p2 = new Phone() ;
		p2.brand = "华为mate40保时捷版" ;
		p2.price = 12999;
		p2.color = "天空之境";
		p2.memory = 128 ;
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color+"---"+p2.memory) ;
		
		//定义第三个Phone类型的变量 p3
		Phone p3 = p1 ;
		p3.brand = "iphone11" ;
		p3.price = 1299 ;
		p3.color ="土豪金" ;
		p3.memory = 64 ;
		System.out.println(p1.brand+"---"+p1.price+"---"+p1.color+"---"+p1.memory) ;	
	}
}

标准类的写法

就是把无参构造和有参构造方法都写进去

class Student{
	//属性私有化
	private String name ;//姓名
	private int age ; //年龄
	private String gender ;//性别
	private String sid ;  //学生学号
	
	//无参构造方法
	public Student(){
		
	}
	
	//有参构造方法
	public Student(String name,int age,String gender,String sid) {
		//赋值
		this.name = name ;
		this.age = age ;
		this.gender = gender ;
		this.sid = sid ;
	}
	
	//提供setXXX()/getXXX()方法
	//给姓名赋值
	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 setGender(String gender){
		this.gender = gender ;
	}
	//获取性别
	public String getGender(){
		return gender ;
	}
	
	//给学号赋值
	public void setSid(String sid){
		this.sid = sid ;
	}
	//获取学号
	public String getSid(){
		return sid ;
	}
	//吃
	public void eat(){
		System.out.println("学生吃营养餐...") ;
	}
	//睡
	public void sleep(){
		System.out.println("学习累了就需要休息") ;
	}
	//学习
	public void study(){
		System.out.println("学习JavaSE...") ;
	}
}
//测试类
class StudentTest{
	public static void main(String[] args){
		//测试学生类
		//方式1:通过无参构造方法 + setXXX()/getXXX()
		Student s = new Student() ;
		s.setName("亚索") ;
		s.setAge(23) ;
		s.setGender("男") ;
		s.setSid("s007") ;
		//获取内容
		System.out.println("姓名为:"+s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()+",学号是:"+s.getSid()) ;
		s.eat() ;
		s.sleep() ;
		s.study() ;
		System.out.println("----------------------------------------") ;
		//方式2:通过有参构造方法赋值+getXXX()获取内容
		Student s2 = new Student("李青",45,"男","s008") ;
		System.out.println("姓名为:"+s2.getName()+",年龄是:"+s2.getAge()+",性别是:"+s2.getGender()+
		",学号是:"+s2.getSid()) ;
		s2.eat() ;
		s2.sleep() ;
		s2.study() ;
	}
}

局部变量和成员变量区别

/*
在程序中的书写位置不同
	局部变量:
		方法定义中或者方法声明上
	成员变量:
		在类中,成员方法外定义的变量
在内存中	
	局部变量:
			在栈内存中
	成员变量:
			在堆内存中	
生命周期不同
	局部变量:
			随着方法调用而存在,随着方法调用完毕而消失!
	成员变量:
			随着对象的创建而存在,随着对象创建完毕之后,不会立即消失,需要等待G C(垃圾回收器空闲时候回收掉!)							
初始化不同
	局部变量:
			可以先定义,但是必须在使用之前必须赋值,否则:可能尚未初始化变量	
	成员变量:
			可以不初始化,它存在系统默认初始化!(根据类型判定)
*/
class Variable{
	//类中,方法外定义的变量
	int x ; 
	//定义一个成员方法
	public void method(int a){//局部变量
		int b =100; //局部变量
		System.out.println("method Variable..."+a) ;
		System.out.println(b) ;
	}
}
//测试类
class VariableDemo{
	public static void main(String[] args){
		//访问x变量
		//创建Variable类的对象
		Variable var = new Variable() ;
		System.out.println(var.x) ;
		var.x = 100 ;
		System.out.println(var.x) ;
		System.out.println("----------------") ;
		//需求:访问Variable类中的method 方法?
		var.method(10) ;
	}	
}

匿名对象

没有 名字的对象

/*
有三种方式传递匿名对象,一般选用下面这种方式,明了
*/
class Student{
	public void study(){
		System.out.println("爱生活,爱Java,爱敲代码...") ;
	}
}
//定义StudentDemo类
class StudentDemo{
	public void method(Student student){
		student.study() ;
	}
}
//测试类
class NoNameObjectDemo{
	public static void main(String[] args){
		//之前的写法
		//访问StudentDemo类中的method 方法
		//创建StudentDemo类对象
		StudentDemo sd = new StudentDemo() ;
		
		//创建一个具体的学生对象
		Student s = new Student() ;
		sd.method(s) ;
		}
	}

封装

为了将某个类的成员属性隐藏(将属性(成员变量)“私有化”),并为之提供公共(public)访问方式!(setXXX()/getXXX())

private

1)可以修饰成员变量,也可以修饰成员方法,但是都只能在本类访问,外界类不能够访问
2)这些被私有修饰的成员变量,或者成员方法,可以间接通过公共方法来访问!

class Student2{
	//成员变量私有化
	private String name ;//姓名
	private int age ; //年龄
	private String gender ;//性别
	private String hobit ; //爱好
	//成员方法
	public void study(){
		System.out.println("学习JavaEE...") ;
	}
	//玩游戏
	public String playGame(String gameName){
		return "会玩"+gameName ;
	}
	//运行
	public void sport(){
		System.out.println("喜欢踢足球...") ;
	} 
	//一些公共访问方法:给姓名,年龄,性别,爱好赋值  /还需要获取这些内容
	//给学生的姓名赋值
	public void setName(String n){ //"高圆圆"
			name = n ;//name = n = "高圆圆"
	}
	//获取学生的姓名--->返回值:String
	public String getName(){
		return name ;
	}
	//给学生的年龄赋值
	public void setAge(int a){ //41
		age = a ; //age = a = 41
	}
	//获取学生的年龄:int类型
	public int getAge(){
		return age ;
	}
	//给学生的性别赋值
	public void setGender(String g){ //"女"
		gender = g ; 	//gender = g  ="女"
	}
	//获取学生的性别:String
	public String getGender(){
		return gender ;
	}
	
	//给学生的爱好赋值
	public void setHobit(String h){	//"跑步"
		hobit = h ;	//hobit = h = "跑步"
	}
	//获取学生的爱好:String
	public String getHobit(){
		return hobit ;
	}	
}
//测试类
class StudentTest2{
	public static void main(String[] args){
		//创建学生类测试
		Student2 s = new Student2() ;
		//对象名.公共的成员方法名() 赋值
		s.setName("高圆圆") ;
		s.setAge(41) ;
		s.setGender("女") ;
		s.setHobit("跑步") ;
		System.out.println("当前学生的姓名是:"+s.getName()+",年龄是:"+s.getAge()+",性别是:"+s.getGender()+",爱好是:"+s.getHobit()) ;
		//其他成员方法
		s.study() ;//学习
		String str = s.playGame("lol") ;
		System.out.println(str) ;
		s.sport() ;
	}
}

手机类

/*
属性:品牌:brand  价格:price  颜色:color 内存:memory
行为:打电话,学习
*/
class Phone{
	//成员变量:私有化
	private String brand ; //品牌
	private int price ; //价格
	private String color ; //颜色
	private String memory ;//内存   "G"
	//公共访问方法:setXXX()/getXXX()方法为私有的成员进行赋值和获取值
	//给品牌属性赋值
	public void setBrand(String b){
		brand = b  ;
	}
	//获取品牌的值
	public String getBrand(){
		return brand ;
	}
	//给价格赋值
	public void setPrice(int p){
		price = p ;
	}
	//获取价格
	public int getPrice(){
		return price ;
	}
	//给手机颜色赋值
	public void setColor(String c){
		color = c ;
	}
	//获取颜色
	public String getColor(){
		return color ;
	}
	
	//给手机内存赋值
	public void setMemory(String m){
		memory = m ;
	}
	//获取内存
	public String getMemory(){
		return memory ;
	}
	//其他成员方法
	//打电话
	public  void call(String toName){
		System.out.println("可以给"+toName+"打电话了...") ;
	}
	//学习
	public void study(){
		System.out.println("使用手机可以学习任何技术...") ;
	}
}
//测试类
class PhoneTest{
	public static void main(String[] args){
		//创建手机类对象
		Phone p = new Phone() ;
		//通过setXXX()属性赋值
		p.setBrand("华为mate30") ;
		p.setPrice(5999) ;
		p.setColor("天空灰") ;
		p.setMemory("128G") ;
		//输出
		System.out.println("手机品牌是:"+p.getBrand()+",价格为:"+p.getPrice()+",颜色是:"+p.getColor()+",内存大小为:"+p.getMemory()) ;
		p.call("牛") ;
		p.study() ;
	}
}

this

/*
this在公司中做项目使用,方便自己,也方便他人
*/
public void setPrice(int price){
		this.price = price ;
	}
	public int getPrice(){
		return price ;
	}

自我总结

这一周的东西很多,但是学的很顺畅,这周讲了面向对象,虽然老师说都一样,但是身边大佬还是很多,我需要多多请教学习,有时候预习的作业有点难理解,第二天老师讲过之后还是能理解,脑子会了,不知道手会不会,代码需要多敲,继续加油!