2021-04-09

一，数组的练习
package cn.tedu.basic;

import java.util.Arrays;
import java.util.Random;

//1.自己实现 获取数组里的最小/大 值
//2.统计取数组里所有数字的总和、平均值
public class Arrayss {
	public static void main(String[] args) {
		int[] suiji = method();//产生随机数的数组
//		method2(suiji);//获取数组里的最小/大 值
		method3(suiji);//获取数组里总和、平均值
	}
	//获取数组里总和、平均值
	public static void method3(int[] a) {
		int sum = 0 ;//定义遍历，记录和
		//1，遍历数组，获取每个数字a[i]
		for (int i = 0; i < a.length; i++) {
			sum = sum + a[i] ;
		}
		System.out.println("总和是： "+sum);
		System.out.println("平均值是： "+ 1.0*sum/a.length);
	}
	//获取数组里的最小/大 值
	public static void method2(int[] a) {
		int min = a[0] ;//定义变量，记录最小值，假设a[0]最小，不对就改
		int max = a[0] ;//定义变量，记录最大值，假设a[0]最大，不对就改
		//1，遍历数组，获取每个数字a[i] 
		for (int i = 0; i < a.length; i++) {
			//遇到了比max还大的就改掉max的值
			if(a[i] > max) {
				max = a[i];
			}
			//遇到了比min还小的就改掉min的值
			if(a[i] < min) {
				min = a[i] ; 
			}
		}
		System.out.println("最小值是： "+min);
		System.out.println("最大值是： "+max);
	}
	//产生随机数的数组
	public static int[] method() {
		//1,创建数组
		int a[] = new int[10];
		//2,遍历数组
		for (int i = 0; i < a.length; i++) {
			//把每个位置的元素,从默认值修改成 随机数
			a[i] = new Random().nextInt(100);
		}
		//3,打印数组里的数据
		System.out.println( Arrays.toString(a));
		return a;
	}
	
}

二，封装
–1,概述
封装是指隐藏对象的属性和实现细节，仅仅对外提供公共的访问方式。
–2,测试
–创建Student类
package cn.tedu.oop;
//测试 封装-private
//总结:
//1,通过private关键字,实现封装,提高资源的安全性(只能在本类里访问)
//2,当属性被private后,需要提供public的getXxx()获取值/setXxx()设置值
//3,当方法被private后,需要提供间接的访问方式
public class Student {
//TODO Fields–成员变量/实例变量
//1,通过private关键字,实现封装,只能在本类中访问使用,别的类用不了.提高了安全性
private String name;
private int no;
private char sex;
//5,Eclipse自动生成get/set
//右键source-generate getters and setters-select all-ok
//3,给外界提供 获取方式get()
public String getName() {
return name;//给外界返回name属性的值
}
//4,给外界提供设置方式set()
public void setName(String name) {
this.name = name;//给name属性赋值
}
public int getNo() {
return no;
}
public void setNo(int no) {
this.no = no;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
this.sex = sex;
}

			//TODO Methods--方法/函数
		//1,通过private关键字,实现封装,只能在本类中访问使用,别的类用不了.提高了安全性
			private void coding() {
				System.out.println("我爱Java");
			}
			public void game() {
		//2,因为coding()被封装了,只能在本类中访问,给外界提供间接的访问方式
				coding();
				System.out.println("王者");
			}
		}

	--创建测试类
		package cn.tedu.oop;
		//测试 封装
		public class Test1 {
			public static void main(String[] args) {
				//TODO 创建Student对象
				Student s = new Student();
				//调用方法
		//		s.coding();//因为coding()被封装了,无法使用
				s.game();
				//设置属性
		//		s.name = "蔡徐坤";//因为name被封装了,无法使用
		//		s.no = 100;
		//		s.sex = '男' ;
				s.setName("渣渣辉");//设置值
				s.setNo(1);
				s.setSex('男');
				//获取属性
		//		System.out.println(s.name);//因为name被封装了,无法使用
		//		System.out.println(s.no);
		//		System.out.println(s.sex);
				System.out.println(s.getName());//获取值
				System.out.println(s.getNo());//获取值
				System.out.println(s.getSex());//获取值
			}
		}

三，构造方法
–1,概述
也是方法，是一个特殊的方法，因为语法/用法/作用都和普通方法不一样
//普通方法语法：修饰符 返回值 方法名（[参数列表]）{方法体}
//普通方法作用：主要用来完成指定的业务
构造方法语法：构造方法语法：修饰符 类名（[参数列表]）{方法体}
构造方法作用：主要用来完成对象的创建 和 对象的初始化
–2，测试
package cn.tedu.oop;
//测试 构造方法
//总结:
//1,作用: 可以用来new + 可以给成员变量赋值
//2,语法: 修饰符 类名([参数列表]){方法体}
//3,构造方法什么时候被触发? – new时
//4,构造方法会隐藏着一个 无参的 构造方法,但是当只提供含参构造方法时,无参构造就没有了
//5,为了外界new的方便两个,可以提供重载的构造方法
//6,如果把构造方法private,那就只能在本类访问,外界无法new
public class Test2 {
public static void main(String[] args) {
//3,创建对象/实例化 时自动触发 构造方法
new Person();//自动触发 无参 的构造方法
new Person(“赵丽颖”);//自动触发 String 的构造方法
new Person(100);//自动触发 int 的构造方法
new Person(“jack”,100);//自动触发 String和int 的构造方法
}
}
//TODO 构造方法–修饰符 类名([参数列表]){方法体}
class Person {
//1,无参的 构造方法,默认就存在的,是隐藏的(前提是:不能只提供含参构造)
public Person(){}
//2,构造方法是一个特殊的方法,可以方法重载
//重载:在一个类里的 方法名相同,但是参数列表不同 现象–灵活
private String s ;
public Person(String name){
s = name;//3,利用构造方法,给成员变量赋值
System.out.println(name);
}
public Person(int age){
System.out.println(age);
}
public Person(String name,int age){
System.out.println(name+age);
}

	}

四，构造代码块
–1，概述
代码块是一段代码 被花括号包起来
代码块根据出现的位置不同，语法用法作用都不同
出现在成员位置（类里方法外）的代码块–构造代码块
出现在局部位置（方法里）的代码块–局部代码块
–2，测试
package cn.tedu.oop;
//测试 构造代码块
//总结：
//1,构造代码块：作用是提取构造方法的共性代码+位置是在类里方法外
//2,构造方法：作用是new/赋值+位置是在类里方法外
//3,局部代码块：作用是控制变量的作用范围+位置是在方法里
//4,执行的顺序：
//当new时，先执行 构造代码块 再执行构造方法
//当方法被调用时，才执行 局部代码块
public class Test3 {
public static void main(String[] args) {
//TODO 2,创建对象测试
new Teacher();
new Teacher(10);
new Teacher(“jack”);
new Teacher(‘中’);
new Teacher(“jack”,20);
}
}
class Teacher{
//TODO 2,构造代码块：位置是在成员位置
//new时被触发而且在构造方法前+用来抽取构造方法的共性
{
//提取了所有构造方法里的重复代码–提高了代码的复用性
System.out.println(“中国人”);
System.out.println(“构造代码块”);
}

	//TODO 1,构造方法/Constructors...
		public Teacher() {
		}
		public Teacher(int a) {
		}
		public Teacher(String b) {
		}
		public Teacher(char c) {}
		public Teacher(String a,int b) {}
		
		public void show() {
			int a = 0; //局部变量
			//3,局部代码块--位置是在方法里+用来控制变量的作用范围
				//当方法被调用时，才能触发
			{
				int b = 10;
				System.out.println("局部代码块");
			}
	//		System.out.println(b);//超出作用域了，用不了
			System.out.println(a);//可以用，在使用范围内
		}
	}

五，this关键字
–1，概述
是一个类里的现象。
互相调用，本类的资源，可以使用this，通常可以省略不写。
两种情况必须写this:当变量名相同时 + 构造方法间调用时
–2，测试
package cn.tedu.oop;
//测试 this关键字
//总结：
//1.this代表本类对象的一个引用,相当于this帮你创建了一个本类的对象
//2.this可以调用同一个类里的所有资源(成员变量/方法/构造方法)
//3,this使用的第一个场景是:用来区别同名的成员变量和局部变量,this调用的一定是成员变量
//4,this使用的第二个场景是:用来在构造方法间互相调用
//位置必须是第一条语句+不能形成类似于死循环的样子
public class Test4 {
public static void main(String[] args) {
new Animal();
}
}
class Animal{
public Animal() {
//4,在 无参构造 调用 含参构造
// this(1);//5,构造方法里,如果出现this,必须是第一条语句
this(“10”);
System.out.println(“无参 构造方法”);
}
public Animal(String a) {
System.out.println(“含参 构造方法”+a);
}
public Animal(int a) {
//3,在 含参构造 调用 无参构造
this();
System.out.println(“含参 构造方法”+a);
}

		String name ="rose";//成员变量
		
		public void eat() {
			String name ="jack";//局部变量
			//1,变量使用的就近原则,优先使用局部变量,jack
			System.out.println(name);
	//2,this底层帮你创建了本类对象,Animal this = new Animal();
	//this代表本类对象的一个引用,this的场景1:
	//当局部变量名 和 成员变量名相同时,通过this 调用成员变量
			System.out.println( this.name );//成员变量rose
		}
		
	}

六，继承
–1，概述
继承是面向对象最显著的一个特性。
继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并 能扩展新的能力。
Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增 加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类/超类/ 基类。
–2,测试
package cn.tedu.oop;
//测试 继承
public class Test5 {
public static void main(String[] args) {
//TODO 3,创建子类对象测试
Dog d = new Dog();
d.eat();//用了父类的
d.sleep();//用了父类的
// System.out.println( d.sifangmoney );//不能继承父类的私有成员

			//TODO 继承的传递性
			DaHuang dh = new DaHuang();
			dh.eat();//用了爷爷类里的功能
			dh.sleep();//用了爷爷类里的功能
			dh.kanjia();//用了父类里的功能
		}
	}
	//1,创建父类--提取子类的所有共性的代码/提高了父类里代码的复用性
	class Animal2{
		//2.3,不能继承父类的私有成员
		private double sifangmoney = 5;
		public void eat() {
			System.out.println("啥都行");
		}
		public void sleep() {
			System.out.println("在睡觉");
		}
	}
	//2,创建子类--使用extends关键字,继承父类后,减少了代码的编写
	class Dog extends Animal2{
		public void kanjia() {}
		//2.2,java只支持单根继承
		//2.1,相当于子类把父类的功能复制了一份
	}
	class DaHuang extends Dog{
		//2.2,java只支持单根继承
		//2.1,相当于子类把父类的功能复制了一份
	}