第四周-Java基础

2022-03-14

day0314

Person类

package day0314;
public class Person {

	public String name;
	public int age;
	public String sex;
	
	public void eat() {
		System.out.println("人吃东西");
	}
	
	public Person() {
		System.out.println("父类Person的无参构造");
	}
	
	public Person(int age) {
		this.age = age + 1; //this.指向成员变量,区分于方法内的局部变量
		System.out.println("父类的单参构造" + age);
	}
	
	public Object sleep() {
		System.out.println("人在睡觉");
		return 0;
	}
	
	public static void a() {
		
	}
	
}

Teacher类

package day0314;
public class Teacher extends Person {

	public int teacherYear;
	public int age; //重写一个与父类重名的成员变量,对父类的成员变量进行隐式
	
	public void teach(String lesson) {
		System.out.println("教师讲" + lesson);
	}
	
	public static void main(String[] args) {
//		Teacher teacher = new Teacher(); //创建Teacher类的对象teacher
//		teacher.teach("数学");
//		teacher.teacherYear = 3;
		Teacher teacher2 = new Teacher(19);
		System.out.println(teacher2.sleep());
	}

	/*子类的无参构造*/
	public Teacher() { //隐式调用父类的无参构造 Person()
		super(); //显示调用父类的无参构造
		System.out.println("子类Person的无参构造");
//		super(); //super() 只能在首行
	}
	
	/*子类的单参构造*/
	public Teacher(int age) { //隐式调用父类的无参构造 Person()
		super(age); //显示调用父类的单参构造，显示调用生效时，不再进行隐式调用
//		super.age = age + 1;
		System.out.println("教师的年龄是" + age);
//		System.out.println("教师的年龄是" + this.age);
//		System.out.println("教师的年龄是" + super.age);
	}
	
	/*子类方法对父类方法的覆盖*/
//	@Override //方法重写(覆盖)的校验注解
//	public void sleep() {
//		System.out.println("教师在睡觉");
//	}
	
	/*在方法重写(覆盖)中,返回类型要与父类方法保持一致,或者是父类返回的子类型*/
	public String sleep() { //报错
		return "123";
	}
	
	/*方法重写不能用于父类的静态方法*/
//	public void a() { //报错
//		
//	}
	
}

Dog类

package day0314;
/**
 * 父类-小狗类
 * @author Katrina
 */
public class Dog {

	protected String name; //protected受保护的，可以被子类所继承
	public int age;
	private String color; //private属性不能被继承
	
	public void eat() {
		System.out.println("小狗吃东西");
	}
	
}

PetDog类

package day0314;
/**
 * 子类-宠物狗
 * 1.extends 继承关键字，后面跟上要继承的父类名称
 * 2.继承用在什么情况下？表示子类对象是父类对象的特例
 * 比如：宠物狗是狗，教师是人，轿车是车
 * 3.子类可以继承（复制）父类的属性和方法，父类不具有子类的属性和方法
 * 4.class 子类 extends 父类 {类体}
 * 5.所有类只能直接继承一个父类（考）
 * 6.子类不能继承父类的private属性，父类属性想被继承，可以定义为protected
 * @author Katrina
 */
public class PetDog extends Dog { //继承父类，Dog

	public String nickName; //昵称
	
	public void wash() {
		System.out.println("给宠物狗洗澡");
	}
	
	public void lookAfter() {
		System.out.println("照料宠物狗");
	}
	
	public static void main(String[] args) {
		Dog dog = new Dog(); //创建一个Dog类的对象dog
//		dog.wash(); //父类不可调用子类的独有方法
//		dog.nickname = "hei"; //父类不可调用子类的独有属性
		
		PetDog petDog = new PetDog(); //创建一个PetDog类的对象petDog
		petDog.age = 10; //继承自父类的属性
		petDog.name = "wangwang"; //继承自父类的属性
//		petDog.color; //报错
		petDog.eat(); //继承了父类的eat()方法
		petDog.wash(); //子类对象调用子类独有的方法
		petDog.nickName = "wenxi"; 
	}
	
}

Car类

package day0314;

public class Car {

	public int speed;

	public void speedUp() {
		speed += 10;
	}
	
}

Bus类

package day0314;
/**
 * 子类-公共汽车类
 * 1.super调用父类的成员变量与父类的成员方法
 * 2.方法覆盖中，子类的成员方法的可见性不能小于父类
 * @author Katrina
 */
public class Bus extends Car {
	
	public int speed; //子类成员变量
	
	/*修饰符为public，方法覆盖，子类成员方法的可见性不能小于父类*/
	public void speedUp() {
		speed += 5;
		super.speedUp(); //调用父类的同名方法
		System.out.println(speed); //不含super，指向当前类的成员变量
		System.out.println(super.speed); //super.属性 指向父类的成员变量
	}
	
	/*子类独有的方法*/
	public void sell() {
		System.out.println("公共汽车售票");
	}
	
	public static void main(String[] args) {
		Bus bus = new Bus();
		bus.speedUp();
	}
	
}

homework

Animal类

package day031401;
/**
 * 父类-动物类
 * 要求：有属性 name\age
 * 有方法 1.bark() 无返回，无参数，输出“动物会叫”
 * 2.吃eat()，有返回，返回吃的东西，有参数，参数是吃的东西
 * 输出“动物吃” + 参数
 * 3.定义狗Dog类，重写bark方法，输出“小狗汪汪叫”，eat方法，输出“小狗吃”+参数
 * 4.定义狗Cat类，重写bark方法，输出“小猫喵喵叫”，eat方法，输出“小猫吃”+参数
 * 5.在测试类Test中，新建小狗、小猫的对象，给他们属性赋值。调用吃和叫
 * @author Katrina
 */
public class Animal {

	String name;
	int age;
	
	public String eat(String thing) {
		System.out.println("动物吃" + thing);
		return thing;
	}
	
	public void bark() {
		System.out.println("动物会叫");
	}
	
}

Cat类

package day031401;

public class Cat extends Animal {

	@Override
	public String eat(String thing) {
//		super.eat("东西");
		System.out.println("小猫吃" + thing);
		return thing;
	}
	
	@Override
	public void bark() {
		System.out.println("小猫喵喵叫");
	}
	
}

Dog类

package day031401;

public class Dog extends Animal {

	@Override
	public String eat(String thing) {
		System.out.println("小狗吃" + thing);
		return thing;
	}
	
	@Override
	public void bark() {
		System.out.println("小狗汪汪叫");
	}
	
}

Test类

package day031401;

public class Test {

	public static void main(String[] args) {
		Cat cat = new Cat();
		cat.name = "大毛";
		cat.age = 2;
		System.out.println("小猫的名字叫" + cat.name + "，今年" + cat.age + "岁了");
		System.out.println(cat.eat("鱼"));
		cat.bark();
		Dog dog = new Dog();
		dog.name = "旺财";
		dog.age = 3;
		System.out.println("狗的名字叫" + dog.name + "，今年" + dog.age + "岁了");
		System.out.println(dog.eat("骨头"));
		dog.bark();
	}
	
}

2022-03-15

day0315

Animal类

package day0315;

public class Animal {

	public int age = 5;
	
	public void eat() {
		System.out.println("动物吃东西");
	}
	
	@Override
	public boolean equals(java.lang.Object obj) {
		// TODO Auto-generated method stub
		return super.equals(obj);
	}

	public boolean equals(Object obj) {
		// TODO Auto-generated method stub
		return false;
	}
	
}

Cat类

package day0315;

public class Cat extends Animal {

	@Override
	public void eat() {
		System.out.println("小猫吃鱼");
	}
	
}

Dog类

package day0315;
import java.lang.Object;
public class Dog extends Animal {

	public int age = 10; //子类与父类同名的属性
	public int weight = 6; //子类独有的属性
	
	/*子类重写父类方法*/
	@Override
	public void eat() { 
		System.out.println("狗吃肉");
	}
	
	/*子类独有方法*/
	public void playBoard() { 
		System.out.println("小狗玩球");
	}
	
	public Dog() {
		
	}
	
	/*构造方法*/
	public Dog(int age, int weight) { 
		this.age = age;
		this.weight = weight;
	}
	
	/*重写equals()方法，输出比较两个对象是同一类的，属性值相等*/
	@Override
	public boolean equals(Object obj) {
		return obj instanceof Dog && this.age == ((Dog)obj).age
				&& this.weight == ((Dog)obj).weight;
	}
	
	/*重写toString()方法，字符串形式输出对象的属性*/
//	@Override
//	public String toString() {
//		return "它的年龄：" + this.age + "，它的重量" + this.weight;
//	}
	
	/*自动生成，右键Source，Genernate toString()*/
	@Override
	public String toString() {
		return "Dog [age=" + age + ", weight=" + weight + ", toString()=" + super.toString() + "]";
	}
	
	
}

Pig类

package day0315;

public class Pig extends Animal {

	@Override
	public void eat() {
		System.out.println("小猪吃饲料");
	}
	
}

Test类

package day0315;
/**
 * 测试类-多态
 * 1.同一对象在不同时刻有不同形态叫多态
 *  Dog dog = new Dog(); Animal a = new Dog();
 * 2.实现多态的前提：
 * 	①有继承/实现关系
 *	②有方法重写
 * 	③父类对子类对象的引用
 * 3.父类对子类对象的引用，成员属性：编译看左边，运行看左边
 * 成员方法：编译看左边，执行看右边
 * 4.好处：声明方法时将父类对象作为形参，方法调用时使用对应子类的实参
 * 最终实现根据传入不同类型的实参，执行不同子类的方法。
 * 程序的扩展性变好，灵活性增强。
 * @author Katrina
 */
public class Test {

	public static void main(String[] args) {
		Dog dog = new Dog(); //创建一个Dog类对象dog
		System.out.println("小狗的年龄和体重分别是" + dog.age + "，" + dog.weight);
		dog.eat();
		dog.playBoard();
		//创建一个Dog类对象，赋值给左边Animal引用 
		//父类名 变量名 = new 子类();
		Animal animal = new Dog(); //编译看到是左边，Animal，所以没有weight会报错
		System.out.println("小狗的年龄和体重分别是" + animal.age + "，");
		animal.eat();
//		animal.playBoard(); //报错
		animal = new Cat(); //创建Cat类的对象，赋值给父类的引用
		trullyEat(animal);
		animal = new Pig();
		trullyEat(animal);
	}
	
	/*真实的调用吃，参数为父类对象引用*/
	public static void trullyEat(Animal animal) {
		//传参的过程 Animal animal = new Cat或者Pig();
		animal.eat();
	}
	
}

Person类

package day0315;

public class Person {

	public void work() {
		System.out.println("人要工作");
	}
	
}

Student类

package day0315;

public class Student extends Person{

	public void tuanke() {
		System.out.println("学生上团课");
	}
	
	@Override
	public void work() {
		System.out.println("学生的工作是学习");
	}
	
}

Teacher类

package day0315;

public class Teacher extends Person {

	@Override
	public void work() {
		System.out.println("教师的工作是上课");
	}
	
}

PersonDemo类

package day0315;
/**
 * 多态中的转型
 * 1.向上转型 从子到父 父类的引用指向子类的对象
 * 语法：父类 变量名 = new 子类();
 * 2.向下转型 从父到子 子类的引用指向父类的变量
 * 语法：子类 变量名 = (子类) 父类变量;
 * 向下转型的作用：可以使用转型后的子类变量访问子类的独有方法
 * 向下转型前提：父类引用的对象与向下转型的子类是同一个
 * 3.可以instanceof，检查对象是否属于某一个类，属于进行向下转型
 * 从大往小转，需要强制转换
 * @author Katrina
 */
public class PersonDemo {

	public static void main(String[] args) {
		//向上转型 从子到父 父类引用指向子类对象
		Person person = new Student(); 
		person.work(); 
//		person.tuanke(); //报错
//		Student student = new Student();
//		student.tuanke();
		//向下转型 从父到子 子类的引用指向父类的变量
//		Student student = (Student) person; //不用新建对象的方法，使用向下转型
//		student.tuanke();
//		Teacher teacher = (Teacher) person; //编译不报错，执行报错。父类引用的对象与向下转型的子类是同一个。 day0315.Student cannot be cast to day0315.Teacher
		if (person instanceof Teacher) { //instanceof 检查对象是否属于某一个类
			Teacher teacher = (Teacher) person; //属于同一类，进行强制转换
		} else {
			System.out.println("person指向的子类不属于Teacher类");
		}
	}
	
}

ObjectDemo类

package day0315;

public class ObjectDemo {

	public static void main(String[] args) {
		//1.equals方法
		ObjectDemo a = new ObjectDemo();
		ObjectDemo b = new ObjectDemo();
		System.out.println(a == b); //比较地址
		System.out.println(a.equals(b));
		Dog c = new Dog(1, 2);
		Dog d = new Dog(1, 2);
		System.out.println(c.age);
		System.out.println(c.weight);
		System.out.println(d.age);
		System.out.println(d.weight);
		
		System.out.println(c.equals(d));
		//2.toString()方法
//		a.toString();
		System.out.println(a);
		System.out.println(c);
		//3.hashCode()方法
		//4.其他方法
	}
	
}

day031501

package day031501;

public class BBQChicken {

	public int price; //价格
	public int weight; //重量
	
	/*无参构造*/
	public BBQChicken() {
		
	}

	public BBQChicken(int price, int weight) {
		this.price = price;
		this.weight = weight;
		System.out.println("你调用了BBQChicken类的两参构造方法");
	}
	
	/*重写equals方法，按比较规则进行补全*/
	@Override
	public boolean equals(Object obj) {
		return obj instanceof BBQChicken && this.price == ((BBQChicken)obj).price
				&& this.weight == ((BBQChicken)obj).weight;
	}
	
}

package day031501;
/**
 * 1.首先有一个类，提取了你要操作的对象的公共属性和方法
 * 2.要明白要做什么？这里比较两个对象是否相等
 * 3.新建了一个测试类，写main方法，进行测试
 * 4.测试类里面新建两个对象
 * 5.比较对象是否相等 equals 对象a.equals(对象b);
 * 6.重写equals方法，按比较规则进行补全
 * 规则的指定：
 * ①比较的对象是不是与被比较的类一致
 * ②按需求对接下来的属性进行比较
 * 7.实际进行比较，输出结果
 * @author Katrina
 */
public class Test {

	public static void main(String[] args) {
		BBQChicken bbqChicken = new BBQChicken(); //先用无参构造，后赋值
		bbqChicken.price = 15;
		bbqChicken.weight = 10;
		BBQChicken bbqChicken2 = new BBQChicken(15, 10); //直接用两参构造完成赋值
		System.out.println(bbqChicken2.equals(bbqChicken)); //false，不重写时，调用的是Object类的equals方法
	}
	
}

2022-03-16

ExceptionDemo类

package day0316;
/**
 * 异常
 * 1.异常信息三部分：异常类型、原因、位置
 * 2.异常类型：
 * ①运行时异常（非受检异常）  RuntimeException
 * ②编译时异常（受检异常），需要进行异常处理才能继续编译
 * 3.JVM默认处理异常：
 * ①抛出异常信息
 * ②终止程序
 * 4.try-catch语句
 * 语法：try {可能出现异常的语句块} 
 * 			catch (异常类型 变量名) {异常的自定义处理}
 * 好处：程序不会中断；可以自行处理异常
 * 5.throws 抛出异常 方法声明的位置。作用：向上抛出异常，给调用方法处理
 * 方法调用方可以处理，也可以继续向上抛出
 * 语法：方法名() throws异常类型 {}
 * 6.try{语句块}catch(Exception 1){处理1}
 * 	catch(Exception 2){处理2}
 * try后面可以跟多个catch语句。当try中出现异常时，被首次捕获后，
 * 执行对应的处理，然后退出整个try-catch语句组
 * 7.try-catch语句中，可以在最后加finally{最终执行的语句}
 * 比如：关闭字节流、断开数据库连接等
 * 8.try语句不能单独存在，后面必须有catch或者finally语句
 * @author Katrina
 */
public class ExceptionDemo {

	public static void main(String[] args) {
		//书写错误
//		int a = 1;
//		byte b = a; //报错，强制转换
		
		/**
		 * 不加try-catch：第二行数组下标越界，第三行包名.类名.main中第几行
		 * Exception in thread "main" 
		 * java.lang.ArrayIndexOutOfBoundsException: 4
		 * at day0316.ExceptionDemo.main(ExceptionDemo.java:19)
		 */
		int[] arr = {1, 2, 3};
		System.out.println("开始");
		try {
			System.out.println(arr[4]); //运行时异常，执行之后，后面的语句不再执行
			String s = null; //栈声明String类型的s，堆没有申请内存资源
			System.out.println(s.length());
			System.out.println("try完毕"); //没有执行
		} catch (ArrayIndexOutOfBoundsException e) { //类 对象
//			e.printStackTrace(); //输出异常信息，与JVM的默认输出一致
//			System.out.println(e.getMessage()); //4，输出异常信息-原因
//			System.out.println(e.toString()); //java.lang.ArrayIndexOutOfBoundsException: 4，输出异常信息-类型和原因
			System.out.println("数组下标越界");
		} catch (NullPointerException e) { //异常被捕获以后，其余不再执行
			System.out.println("空指针异常");
		} finally {
			System.out.println("最终");
		}
		System.out.println("结束");
		/**
		 * 加try-catch：
		 * 开始
		 * java.lang.ArrayIndexOutOfBoundsException: 4
		 * at day0316.ExceptionDemo.main(ExceptionDemo.java:32)
		 * 结束
		 * 如果注释e.printStackTrace();不进行处理，掩盖错误，则只输出开始 结束
		 */
		
		/**
		 * 第一行：控制指针异常
		 * Exception in thread "main" java.lang.NullPointerException
		 * at day0316.ExceptionDemo.main(ExceptionDemo.java:26)
		 */

	}
	
}

ThrowsDemo类

package day0316;

public class ThrowsDemo {

	public static void main(String[] args) { //抛给JVM虚拟机处理，该出错出错
		try {
			method(); //调用方法时针对抛过来的异常 1.进行处理
			//2.或者继续向上抛出
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("我收到了异常信息");
		}
	}
	
	public static void method() throws Exception { 
		//方法内部不处理可能出现的异常，直接向上（向外）抛出
		int[] arr = {1, 2, 3};
		System.out.println(arr[3]);
	}
	
}

Cat类

package day0316;

public class Cat {

	private int age;
	private String name;
	private int weight;
	private String sex;
	
	/*set方法 根据传参设置对象的属性 可以加一点处理*/
	public void setWeight(int weight) {
		//int weight = 10; 传参
//		if (weight > 10) { //可以加一点处理
//			System.out.println("小猫重量不能超过10斤");
//			return; //程序到此结束
//		}
		this.weight = weight;
	}
	
	/*get方法，得到对象的属性值，无参数有返回*/
	public int getWeight() {
//		return this.weight;
		return weight;
	}
	
	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 String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}
	
}

Test类

package day0316;

public class Test {

	public static void main(String[] args) {
		Cat cat = new Cat();
//		cat.weight = 100000;
		cat.setWeight(15);
		System.out.println(cat.getWeight());
		cat.setName("kitty");
		System.out.println(cat.getName());
		cat.setAge(20);
		System.out.println(cat.getAge());
		cat.setSex("男");
		System.out.println(cat.getSex());
		System.out.println("执行结束");
	}
	
}