Day07

一,复习
–1,数组的练习
–随机打印数组里的数据
private static void method6() {
int a[] = {98, 2, 81, 49, 96, 8, 83, 68, 95, 34};
//控制下标i的取值范围
int i = new Random().nextInt(a.length) ;
System.out.println(a[i]);
}
–获取数组里的最大值最小值
private static void method7() {
int a[] = {9, 2, 81, 49, 96, 8, 83, 68, 95, 34};
int max = a[0] ;//假设最大值是a[0]
int min = a[0] ;//假设最小值是a[0]
//遍历数组，获取每个值a[i]
for (int i = 0; i < a.length; i++) {
if(max < a[i]) {//如果max不是最大值，修改max的值
max = a[i] ;
}
//如果后面的比min还小，修改min的值
if(min > a[i]) {
min = a[i] ;
}
}

			//或者
			Arrays.sort(a);
			System.out.println("最小值是： "+a[0]);
			System.out.println("最大值是： "+a[a.length-1]);
			
		}
	--统计数组里的数据总和和平均值
		private static void method8() {
			int a[] = {9, 2, 81, 49, 96, 8, 83, 68, 95, 34};
			
			int sum = 0 ;//定义变量，记录和
			//遍历数组，获取每个数据a[i]
			for (int i = 0; i < a.length; i++) {
				sum = sum + a[i] ;//修改sum的值
			}
			System.out.println("数据的总和是： "+sum);
			System.out.println("数据的平均数是： "+sum/a.length);
		}
	--统计数组里偶数的和
	--模拟数组复制

二,多个对象的使用
–1，代码
package cn.tedu.oop;
//测试 多个对象的创建
public class Test1_New {
public static void main(String[] args) {
Person p = new Person();
p.study();
p.name = “jack”;
p.age=20;
System.out.println( p.name );
System.out.println( p.age );
Person p2 = new Person();
p2.study();
p2.name=“rose”;
p2.age=18;
System.out.println(p2.name);
System.out.println(p2.age);

			Person p3 = p2;
			System.out.println(p3.name);
			System.out.println(p3.age);
		}
	}
	class Person{
		String name;//null
		int age;//0
		public void study() {
			System.out.println("coding...");
		}
	}

三,封装
–1，概述
只要体现两点好处：复用性提高了 + 安全性提高了
通过关键字private实现，
只要被private修饰后，资源 只能在 本类中 访问
–2，测试
package cn.tedu.oop;
// 测试 封装private
//总结
//1, 封装主要使用private关键字来实现
//2, 被封装的资源,提高了安全性. 只能在本类中访问,别的类都访问不了
//3, 如果别的类里,非要访问私有资源,只能提供公共的方法
//4, 当方法被私有后,外界无法 直接访问,只能间接访问
//5, 当属性被私有后,外界无法 直接访问,只能访问set()设置值,访问get()获取值
public class Test2_Private {
public static void main(String[] args) {
//创建对象测试
Student s = new Student();
// s.coding();//2，coding()被封装了，只能在自己的类中使用
s.show();//4,访问间接的 公开的 方法
//设置了属性的值
//s.name=“jack”;//6，被封装了，只能在自己的类中使用
s.setName(“jack”);//8，调用公开的set()设置值
//获取了属性的值
//System.out.println(s.name);
System.out.println( s.getName() );//10，调用公开的get()获取值
// s.age=20;
s.setAge(10);//设置值
// System.out.println(s.age);
System.out.println( s.getAge() );//获取值
//TODO
s.setGender(‘男’);
System.out.println( s.getGender() );
s.setScore(99.9);
System.out.println( s.getScore() );
}
}
class Student{
//TODO 封装以下属性并提供get()/set()
private char gender ;
private double score;
//右键-source-generate setters and getters…select all…ok
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public double getScore() {
return score;
}
public void setScore(double score) {
this.score = score;
}
//public 的set()设置值
private int age ;
public void setAge( int a ) {
age = a ;//给age属性赋值
}
//public的get()获取值
public int getAge() {
return age;//返回age属性的值
}
private String name;//5,被封装的资源，只能在本类中访问
//7，当属性，被封装后，需要设置值时–提供 公开的 setXxx()
public void setName( String n ){
name = n ;//给name属性设置值
}
//9，当属性，被封装后，需要获取值时–提供 公开的 getXxx()
public String getName(){
return name;//返回name属性的值
}
//1,把资源提高安全性，可以使用private关键字表示封装–只能在 本类中 访问
private void coding() {
System.out.println(“coding…”);
}
//3,在本类中，提供一个 间接的 访问coding()的方式
public void show() {
coding();
}
}

四,构造方法
【特点】
1、子类的构造的过程中必须调用其基类的构造方法。
2、子类可以在自己的构造方法中使用super(argument_list)调用基类的构造方法。
3、如果子类的构造方法中没有显示地调用基类构造方法，则系统默认调用基类无参数的构造方法。
使用this(argument_list)调用本类的另外的构造方法
如果调用super，必须写在子类构造方法的第一行
4、如果子类构造方法中既没有显示调用基类构造方法，而基类中又没有无参的构造方法，则编译出错。
–1,概述
是一个与类名相同的 方法
通常实例化对象时,会自动触发构造方法
构造方法的作用:用来创建对象 和 完成对象的初始化
–2,语法
修饰符 类名([参数列表]){方法体}
–3,测试
package cn.tedu.oop;
//测试 构造方法
//总结:
//1, 当你创建对象时, 一定会 触发 构造方法
//2, 无参构造默认就有,但是,只提供含参构造时,就真没了…
//3, 语法:
//普通方法的: 修饰符 返回值 方法名(参数列表){方法体}
//构造方法的: 修饰符 类名(参数列表){方法体}
//4, 构造方法的作用是: 创建对象时用,创建对象时才触发
//5, 构造方法可以重载,可以提供好多个构造方法?–方便外界创建对象
public class Test3_Constructor {
public static void main(String[] args) {
//1,当创建对象时,一定 会自动触发构造方法
Teacher t = new Teacher();//匹配无参构造
Teacher t2 = new Teacher(“皮皮霞”);//匹配public Teacher(String a)构造
Teacher t3 = new Teacher(“皮皮霞”,19);//匹配public Teacher(String a,int b)构造
Teacher t4 = new Teacher(20);//匹配public Teacher(int a)
System.out.println( t4.age );
Teacher t5 = new Teacher(20,“杨幂”);//匹配public Teacher(int a,String b)
}
}
class Teacher{
int age ;//赋值的方式: set() + 构造方法
//TODO 修饰符 类名([参数列表]){方法体}
//2, 无参构造 是隐藏着的,默认就存在的–前提是:不能只提供含参构造
public Teacher() {
System.out.println(1);
}
//3, 提供重载的 含参的 构造方法:: 同一个类里,方法名相同,但是参数列表不同的现象
public Teacher(int a) {
age = a ;//TODO 完成对象的初始化
}
public Teacher(int a,String b) {
System.out.println(a+b);
}
public Teacher(String a,int b) {
System.out.println(a+b);
}
public Teacher(String a) {
System.out.println(a);
}
}
五,代码块
–1,概述
代码块就是一块被包起来的代码
代码块出现的位置不同,名字和作用和用法都不同.
出现在成员位置(类里方法外)的代码块,叫构造代码块
出现在局部位置(方法里)的代码块,叫局部代码块
–2,构造代码块
–在类的内部，方法外部，的代码块。
–通常用于抽取构造方法中的共性代码。
–每次调用构造方法前都会调用构造代码块
–优先于构造方法加载
–3,局部代码块
–在方法里面的代码块
–通常用于控制变量的作用范围，出了括号就失效
–变量的范围越小越好，成员变量会有线程安全问题
–4,测试
package cn.tedu.oop;
// 测试 代码块
//总结:
//1, 构造方法: 用来 创建对象或者完成对象的初始化 + new时触发
//2, 构造代码块: 位置是在类里方法外 + 抽取构造方法的共性 + new时触发
//3, 局部代码块: 位置是在方法里 + 控制变量的作用范围 + 当方法被调用时触发
//4, 执行顺序:
//new时: 构造代码块 > 构造方法 > 局部代码块(调用方法时)
public class Test4_Block {
public static void main(String[] args) {
//TODO
new Animal().show();
new Animal(“大黄”);
new Animal(5);
}
}
class Animal{
//1,构造代码块: 在类里方法外+在执行构造方法前执行+抽取构造方法的共性
{
int age = 0;
System.out.println(“构造代码块”);
}
//TODO Constructors
public Animal() {
}
public Animal(String n) {
System.out.println(n);
}
public Animal(int a) {
System.out.println(a);
}
public void show() {
//2, 局部代码块:位置是在方法里 + 控制变量的作用范围
{
int x = 10;//?
System.out.println(x);
}
}

	}

六,this关键字
–1,概述
this表示本类对象的一个引用对象
this多数情况下都是省略不写的,但是有两种情况必须使用this
–场景1 :当局部变量名 和成员变量名 相同时
–场景2 :当同一个类里的 构造方法 互相调用时
–2,测试
package cn.tedu.oop;
//测试 this关键字
public class Test5_This {
public static void main(String[] args) {
//TODO
new Demo().show();
}
}
class Demo{

		int age = 20 ;
		String name ;
		
		public void show() {
			int age = 10 ;
			System.out.println(age);//就近原则,当变量名相同时,优先使用局部变量,10
			System.out.println(name);//null
			
			//1, this关键字的作用, 就相当于this在底层帮你创建了一个本类对象
			//Demo this = new Demo();  this--表示的是本类对象的一个引用
			//2, this可以调用本类的成员(成员变量/方法)
			System.out.println( this.age );//3, 使用this调用成员变量age
		}
		
	}

扩展:
–1,面试题:
package cn.tedu.oop;
public class Test4_Block {
public static void main(String[] args) {
new Animal();//1 2 4
new Animal(5);//1 3
}
}
class Animal{
public Animal(){//无参构造
System.out.println(2);
{
System.out.println(4);//局部代码块
}
}
public Animal(int a){//含参构造
System.out.println(3);
}
{
System.out.println(1);//构造代码块
}
}