public class Test {
public static void main(String[] args) {
/*
final修饰方法：
表明该方法是最终方法，不能被重写
final修饰类：
表明该类是最终类，不能被继承
final修饰变量：
叫做常量，只能被赋值一次
*/
final int a = 10;
System.out.println(a);
}
}
final class Fu{
public void show(){
System.out.println("父类的show方法");
}
}
/*
class Zi extends Fu{
}*/
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
/*
final 修改基本数据类型：记录的值不能发生改变
final 修饰引用数据类型：记录的地址值不能发生改变，内部的属性值还是可以改变的
核心：
常量记录的数据是不能发生改变的。
字符串是不可变的
*/
final double PI = 3.14;
//创建对象
final Student S = new Student("zhangsan",23);
//记录的地址值不能发生改变，内部的属性值还是可以改变的
//S = new Student();
S.setName("李四");
S.setAge(24);
System.out.println(S.getName() + ", " + S.getAge());
//数组
final int[] ARR = {1,2,3,4,5};
//ARR = new int[10];
ARR[0] = 10;
ARR[1] = 20;
//遍历数组
for (int i = 0; i < ARR.length; i++) {
System.out.println(ARR[i]);
}
}
}
public class Teacher {
private String name;
private int age;
public Teacher() {
}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Teacher {
private String name;
private int age;
public Teacher() {
}
public Teacher(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
//创建对象
/*Student s = new Student();
s.setName("张三");
s.setAge(23);
System.out.println(s.getName() + ", " + s.getAge());*/
/* String s = "abc";
System.out.println(s);*/
com.itheima.domain1.Teacher t = new com.itheima.domain1.Teacher();
com.itheima.domain2.Teacher t2 = new com.itheima.domain2.Teacher();
}
}
public class CodeBlockDemo1 {
public static void main(String[] args) {
/*{
int a = 10;
}//因为当代码执行到这里时，变量a就从内存中消失了
//System.out.println(a);*/
//创建对象
Student s = new Student();
Student s2 = new Student("zhangsan",23);
Student s3 = new Student("zhangsan");
}
}
public class Student {
private String name;
private int age;
//构造代码块：
//1.写在成员位置的代码块
//2.作用：可以把多个构造方法中重复的代码抽取出来
//3.执行时机：我们在创建本类对象的时候会先执行构造代码块再执行构造方法
//渐渐的淘汰了
{
System.out.println("开始创建对象了");
}
public Student() {
System.out.println("空参构造");
}
public Student(String name, int age) {
System.out.println("有参构造");
this.name = name;
this.age = age;
}
public Student(String name) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Student {
private String name;
private int age;
//执行时机：
//随着类的加载而加载的，并且只执行一次。
static {
System.out.println("静态代码块执行了");
}
public Student() {
System.out.println("空参构造");
}
public Student(String name, int age) {
System.out.println("有参构造");
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Test {
public static void main(String[] args) {
//创建对象
Student s1 = new Student();
Student s2 = new Student("zhangsan",23);
}
}
public class Administrator extends Person {
@Override
public void show() {
System.out.println("管理员的信息为：" + getName() + ", " + getAge());
}
}
public class Person {
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void show(){
System.out.println(name + ", " + age);
}
}
public class Student extends Person{
@Override
public void show() {
System.out.println("学生的信息为：" + getName() + ", " + getAge());
}
}
public class Teacher extends Person{
@Override
public void show() {
System.out.println("老师的信息为：" + getName() + ", " + getAge());
}
}
public class Test {
public static void main(String[] args) {
//创建三个对象，并调用register方法
Student s = new Student();
s.setName("张三");
s.setAge(18);
Teacher t = new Teacher();
t.setName("王建国");
t.setAge(30);
Administrator admin = new Administrator();
admin.setName("管理员");
admin.setAge(35);
register(s);
register(t);
register(admin);
}
//这个方法既能接收老师，又能接收学生，还能接收管理员
//只能把参数写成这三个类型的父类
public static void register(Person p){
p.show();
}
}
public class Test {
public static void main(String[] args) {
//创建对象（多态方式）
//Fu f = new Zi();
Animal a = new Dog();
//调用成员变量：编译看左边，运行也看左边
//编译看左边：javac编译代码的时候，会看左边的父类中有没有这个变量，如果有，编译成功，如果没有编译失败。
//运行也看左边：java运行代码的时候，实际获取的就是左边父类中成员变量的值
System.out.println(a.name);//动物
//调用成员方法：编译看左边，运行看右边
//编译看左边：javac编译代码的时候，会看左边的父类中有没有这个方法，如果有，编译成功，如果没有编译失败。
//运行看右边：java运行代码的时候，实际上运行的是子类中的方法。
a.show();///Dog --- show方法
//理解：
//Animal a = new Dog();
//现在用a去调用变量和方法的呀？是的
//而a是Animal类型的，所以默认都会从Animal这个类中去找
//成员变量：在子类的对象中，会把父类的成员变量也继承下的。父：name 子：name
//成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖的。
}
}
class Animal{
String name = "动物";
public void show(){
System.out.println("Animal --- show方法");
}
}
class Dog extends Animal{
String name = "狗";
@Override
public void show() {
System.out.println("Dog --- show方法");
}
}
class Cat extends Animal{
String name = "猫";
@Override
public void show() {
System.out.println("Cat --- show方法");
}
}
public class Test {
public static void main(String[] args) {
//创建对象
Animal a = new Dog();
//编译看左边，运行看右边
a.eat();
//多态的弊端
//不能调用子类的特有功能
//报错的原因？
//当调用成员方法的时候，编译看左边，运行看右边
//那么在编译的时候会先检查左边的父类中有没有这个方法，如果没有直接报错。
//a.lookHome();
//解决方案：
//变回子类类型就可以了
//细节：转换的时候不能瞎转，如果转成其他类的类型，就会报错
//Cat c = (Cat) a;
//c.catchMouse();
/*if(a instanceof Dog){
Dog d = (Dog) a;
d.lookHome();
}else if(a instanceof Cat){
Cat c = (Cat) a;
c.catchMouse();
}else{
System.out.println("没有这个类型，无法转换");
}*/
//新特性
//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d
//如果不是，则不强转，结果直接是false
if(a instanceof Dog d){
d.lookHome();
}else if(a instanceof Cat c){
c.catchMouse();
}else{
System.out.println("没有这个类型，无法转换");
}
}
}
class Animal{
public void eat(){
System.out.println("动物在吃东西");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
public void lookHome(){
System.out.println("狗看家");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃小鱼干");
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
public class Animal {
/*属性：
年龄，颜色
行为:
eat(String something)(something表示吃的东西)*/
private int age;
private String color;
public Animal() {
}
public Animal(int age, String color) {
this.age = age;
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public void eat(String something){
System.out.println("动物在吃" + something);
}
}
public class Cat extends Animal {
public Cat() {
}
public Cat(int age, String color) {
super(age, color);
}
/*eat(String something)方法(something表示吃的东西)
逮老鼠catchMouse方法(无参数)*/
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的猫眯着眼睛侧着头吃" + something);
}
public void catchMouse(){
System.out.println("猫抓老鼠");
}
}
public class Dog extends Animal {
/* 1.定义狗类
行为:
eat(String something)(something表示吃的东西)
看家lookHome方法(无参数)*/
//空参构造
//带全部参数的构造
public Dog() {
}
public Dog(int age, String color) {
super(age, color);
}
//行为
//eat(String something)(something表示吃的东西)
//看家lookHome方法(无参数)
@Override
public void eat(String something) {
System.out.println(getAge() + "岁的" + getColor() + "颜色的狗两只前腿死死的抱住" + something + "猛吃");
}
public void lookHome(){
System.out.println("狗在看家");
}
}
public class Person {
/* 属性：
姓名，年龄
行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
行为：
keepPet(Cat cat,String something)方法
功能：喂养宠物猫，something表示喂养的东西
生成空参有参构造，set和get方法
4.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下：
年龄为30岁的老王养了一只黑颜色的2岁的狗 //对饲养员的描述
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃 //当狗在吃东西的时候的描述
keepPet(Cat cat,String somethind)方法打印内容如下：
年龄为25岁的老李养了一只灰颜色的3岁的猫
3岁的灰颜色的猫眯着眼睛侧着头吃鱼*/
private String name;
private int age;
public Person() {
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//饲养狗
/* public void keepPet(Dog dog, String something) {
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + dog.getColor() + "颜色的" + dog.getAge() + "岁的狗");
dog.eat(something);
}
//饲养猫
public void keepPet(Cat cat, String something) {
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + cat.getColor() + "颜色的" + cat.getAge() + "岁的猫");
cat.eat(something);
}*/
//想要一个方法，能接收所有的动物，包括猫，包括狗
//方法的形参：可以写这些类的父类 Animal
public void keepPet(Animal a, String something) {
if(a instanceof Dog d){
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + a.getColor() + "颜色的" + a.getAge() + "岁的狗");
d.eat(something);
}else if(a instanceof Cat c){
System.out.println("年龄为" + age + "岁的" + name + "养了一只" + c.getColor() + "颜色的" + c.getAge() + "岁的猫");
c.eat(something);
}else{
System.out.println("没有这种动物");
}
}
}
/* 根据需求完成代码:
1.定义狗类
属性：
年龄，颜色
行为:
eat(String something)(something表示吃的东西)
看家lookHome方法(无参数)
2.定义猫类
属性：
年龄，颜色
行为:
eat(String something)方法(something表示吃的东西)
逮老鼠catchMouse方法(无参数)
3.定义Person类//饲养员
属性：
姓名，年龄
行为：
keepPet(Dog dog,String something)方法
功能：喂养宠物狗，something表示喂养的东西
行为：
keepPet(Cat cat,String something)方法
功能：喂养宠物猫，something表示喂养的东西
生成空参有参构造，set和get方法
4.定义测试类(完成以下打印效果):
keepPet(Dog dog,String somethind)方法打印内容如下：
年龄为30岁的老王养了一只黑颜色的2岁的狗 //对饲养员的描述
2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃 //当狗在吃东西的时候的描述
keepPet(Cat cat,String somethind)方法打印内容如下：
年龄为25岁的老李养了一只灰颜色的3岁的猫
3岁的灰颜色的猫眯着眼睛侧着头吃鱼
5.思考：
1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？*/
public class Test {
public static void main(String[] args) {
//创建对象并调用方法
/* Person p1 = new Person("老王",30);
Dog d = new Dog(2,"黑");
p1.keepPet(d,"骨头");
Person p2 = new Person("老李",25);
Cat c = new Cat(3,"灰");
p2.keepPet(c,"鱼");*/
//创建饲养员的对象
Person p = new Person("老王",30);
Dog d = new Dog(2,"黑");
Cat c = new Cat(3,"灰");
p.keepPet(d,"骨头");
p.keepPet(c,"鱼");
}
}
public class Animal {
public String name;
public void show(){
System.out.println(name);
}
}
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
System.out.println(a.name);
}
}
import com.itheima.demo1.Animal;
public class Dog extends Animal {
public void show() {
System.out.println(name);
}
}
import com.itheima.demo1.Animal;
public class Test {
public static void main(String[] args) {
Animal a = new Animal();
System.out.println(a.name);
}
}
单词
