***Debug操作***
package cn.tedu.oopextends;
/**本类用于Debug的学习
* 1.我们可以在目标码前面,符号后面添加断点(红点),再按一次取消断点
* 2.Debug断点调试的时候,需要以Debug."TestDebug.main()"的方式启动
* 3.弹出来的窗口有两个:
* Debugger:这个是Debug模式用于查看执行情况,比如变量当前值的窗口
* Console--这个是我们之前常用的控制台,会显示程序执行的效果
* 4.按F8进行下一步,想结束Debug就按左边红色方块按钮结束程序
* 另外注意:Debug只会在断点处停下来,不打断点的位置不会停,要学会合理设置断点的设置*/
public class TestDebug {
public static void main(String[] args) {
for(int i =1;i<=10;i++){
System.out.println(i);
}
}
}
1.静态 static
- static是关键字
- 可以修饰成员变量和方法,被修饰的资源就是静态资源
- 静态资源优先于对象加载,随着类的加载而加载,只加载一次,就会一直存在,不再开辟新空间, 直到类消失才一起消失
- 被静态修饰的资源可以通过类名直接调用
- 静态资源全局共享(被所有对象共享),值只有一份
- 不能在静态代码块中使用this或者super
1.1练习:static入门案例
package cn.tedu.oopstatic;
/**本类用于测试静态的入门案例*/
public class TestStatic1 {
public static void main(String[] args) {
/**3.静态资源可通过类名直接直接调用,无需创建对象
* 4.静态资源优先于对象加载的,随着类的加载而加载
* 比对象优先加载到内存,没对象时也可以通过类名进行直接调用*/
System.out.println(Student.name);
Student.speak();
//4.创建Student类的对象并进行测试
Student s= new Student();
Student s1= new Student();
System.out.println(s.name);
s.study();
//6.测试给属性name赋值
s.name = "小乔";
System.out.println(s1.name);//属性值改之前不影响,改之后全部对象都会影响
s1.name = "黄桃罐头";
/**5.静态资源可被全局所有对象(new)共享,值只有一份*/
System.out.println(Student.name);
System.out.println(s.name);
System.out.println(s1.name);
}
}
//1.通过抽象封装一个学生类
class Student{
//2.创建属性--成员变量--有默认值,无需手动初始化
/**1.可以通过static将普通资源修饰成静态资源
* 2.static可以修饰成员变量和普通方法,一般写在修饰符的后面*/
//5.1将成员变量name修饰成静态
static String name;//姓名
int sno;//学号
//3.创建行为--普通方法
public void study(){
System.out.println("我一点都不想过端午,满脑子都是学java~~");
}
//5.2将speak方法修饰成静态
public static void speak(){
System.out.println("会就要大声说出来!!!");
}
}
1.2练习:测试静态资源与普通资源的调用关系
调用关系:静态资源只能调用静态资源
非静态资源看调用静态资源,也可调用非静态资源
package cn.tedu.oopstatic;
/***本类用于测试静态资源与普通资源的调用关系*/
public class TestStatic2 {
}
//1.首先封装一个老师类
class Teacher{
//2.定义普通资源
//2.1定义普通属性
String name;
//2.2定义普通方法
public void teach(){
/**1.普通资源能否调用静态资源?--可以!!!*/
System.out.println(age);//普通资源可以调用静态属性
eat();//普通资源可以调用静态方法
System.out.println("正在授课ing~~");
}
//3.定义静态资源
//3.1定义静态属性
static int age;
//3.2定义静态方法
public static void eat(){
/**2.静态资源能否调用普通资源?--不可以!!!*/
//System.out.println(name);//静态资源不能调用非静态属性
//teach();
System.out.println("扶我起来,我还能吃!!!");
}
public static void sleep(){
/**3.静态资源能否调用静态资源?--可以*/
System.out.println(age);
eat();//静态方法可以调用静态方法
System.out.println("我是静态修饰方法");
}
}
2.静态代码块、构造代码块、局部代码块
2.1静态代码块的格式:
静态资源随着类的加载而加载,并且只被加载一次,一般用于项目的初始化
特点: 被static修饰
2.2三种代码块的比较:
1.静态代码块:
*格式:static{方法体}
*位置:类里方法外
*触发时机:静态代码块也是静态资源,随着类的加载而加载,优先于对象加载,并且只加载一 次的资源
*作用:用于专门完成一些需要第一时间就加载且加载一次的资源
2.构造代码块:
*格式:{ }
*位置:类里方法外
*执行时机:创建对象时触发,优先构造方法执行
*作用:用于提取所有构造方法的共性功能内容
3.局部代码块:
*格式{ }
*位置:普通方法里
*执行时机:调用当前局部代码块所处的方法时才触发
*作用:用来控制变量的作用范围,变量的作用范围越小越好
4.执行顺序:
静态代码块--》构造代码块--》构造方法【创建好对象】--》调用局部代码块所处的普通方法
5.为什么是这样的顺序呢?
因为静态代码块也是静态资源,静态资源随着类的加载而加载,优先于对象的创建
静态资源只加载一次,且一直存在,直到类的消失,它才会消失;而构造方法随着创建对象而触发,创建几次就触发几次。
练习:静态/构造/局部代码块之间的关系
package cn.tedu.block;
/**几种代码块的关系以及执行顺序*/
public class TestBlock {
public static void main(String[] args) {
//7.创建对象
Phone p = new Phone();
Phone p1 = new Phone();
/**1.在创建对象(或者多个对象)之前会优先自动执行静态代码块,而且此静态代码块只执行一次,
* 2.每次创建对象时,都会调用构造代码块与构造方法,构造代码块先执行
* 3.当对象调用方法时,若方法里有局部代码块,局部代码块才会触发*/
p.sleep();
}
}
//1.Phone类
class Phone{
//2.创建静态代码块
/**静态代码块:
* 位置:类里方法外
* 触发时机:静态代码块也是静态资源,随着类的加载而加载,优先于对象加载,并且只加载一次的资源
* 作用:用于专门完成一些需要第一时间就加载的资源*/
static{
System.out.println("我是静态代码块!!!");
}
//3.创建构造代码块
/**构造代码块:
* 位置:类里方法外
* 触发时机:创建对象时触发,而且优先于构造方法执行
* 作用:用于提取所有构造方法的共性内容*/
{
System.out.println("我是一个构造代码块~~");
}
//4创建构造方法
/**构造方法:是与类同名且没有返回值类型的方法,用于创建对象,在创建对象时触发*/
public Phone(){
System.out.println("我是一只叫构造方法的狗狗");
}
//5.创建普通方法--功能
public void sleep(){
System.out.println("起来嗨!!");
//6.创建局部代码块
/**局部代码块:
* 位置:普通方法里
* 执行时机:调用本方法时触发
* 作用:用来控制变量的作用范围,变量的作用范围越小越好*/
{
System.out.println("我是一枚局部代码块%%%");
}
}
}
3.final
final是一个关键字,表示最终
1).被final修饰的类是最终类,不能被继承
2).被final修饰的方法是方法的最终实现,不能被重写
3).被final修饰的变量变成了一个常量,值不能被修改,常量在定义(声明)的时候就需要赋值,否则报错
4).常量的定义形式:final 数据类型 常量名 = 值;
练习:final修饰的作用
package cn.tedu.oopfinal;
/**本类用于final的入门案例*/
public class TestFinal {
public static void main(String[] args) {
//6.创建Son类对象进行测试
Son s = new Son();
s.work();
//s.work1();
// s.name = "干饭人";//对父类的name重新赋值并查看
System.out.println(s.name);
}
}
//1.父类
/**1.Final表示最终,可以用来修饰类
* 但是被final修饰的类无法被继承
* 也就是没有子类,它自己就是最终类
*/
//7.1final class Father{//报错:Son不能继承被final修饰的Father类
class Father{
//3.创建成员变量
/**3.final可以用来修饰成员变量,被final修饰的变量值不可以被修改,变成了常量
* 注意:常量在定义的时候就需要赋值,否则报错*/
final String name = "打工人";
//String name = "打工人";
//4.创建普通方法
//7.2final修饰方法
//final public void work(){//报错:子类不可以重写父类中被final修饰的方法
/**2.final可以用来修饰方法,被final修饰的方法是方法的最终实现,不能被重写*/
public void work(){
System.out.println("Father...打工人,打工魂~~");
}
}
//2.子类并继承父类
class Son extends Father{
public void work1(){//在新方法中调用父类方法
super.work();
}
//5.创建子类重写父类的work方法
public void work(){
System.out.println("Son...现在打工人都用计算机打工!!!");
}
}
4.面向对象之多态
面向对象的三大特征:封装private、继承extends、多态(继承+重写)
4.1多态:
指一类事物具有多种形式,比如:水果有苹果、橘子、香蕉等;动物有猫、狗、大象等
1.多态的前提继承+方法重写缺一不可
2.口诀1:父类引用 指向子类对象 如:Animal a = new Cat( );
口诀2:编译(保存)看左边,运行(测试run)看右边 解释:方法的声明看父类,方法的实现看子类
练习:创建多态对象的过程
/**本类用于多态的入门案例*/
public class TestDemo {
public static void main(String[] args) {
//5.创建对象进行测试
Animal a = new Animal();
Cat c = new Cat();//格式:子类引用 = 子类对象
Dog d = new Dog();
a.eat();//小动物Animal吃啥都行~~
c.eat();//小猫Cat爱吃小鱼干!!!
// a.jump();//父类无法使用子类的特有功能
c.jump();//小猫Cat跳的特别高@@@
/**8.创建多态对象进行测试
* 口诀1:父类引用 指向子类对象
* 口诀2:编译(保存)看左边,运行(测试)看右边
* 多态的两个前提:继承+重写缺一不可
* 多态使用的是父类的声明,子类的具体实现*/
Animal a2 = new Cat();
a2.eat();//小猫Cat爱吃小鱼干!!!
/**多态不可以调用子类特有的功能,只能调用重写的功能*/
//a2.jump;//子类独有的功能,父类不能引用,引用的前提下是继承+重写
Animal a3 = new Dog();
a3.eat();//小动物Animal吃啥都行~~//因为Dog类没有重写,继承的是父类的方法
/**多态的出现是为了统一调用标准,向父类看齐
* 父类声明的功能才能用,子类特有的功能用不了
* 如果想要子类的特有功能,就创建纯纯的子类对象*/
}
}
//1.创建父类
class Animal{
//4.创建父类普通方法
public void eat(){
System.out.println("小动物Animal吃啥都行~~");
}
}
//2.子类小猫,继承父类Animal
class Cat extends Animal{
//6.重写父类中的普通方法eat()
@Override
public void eat(){
System.out.println("小猫Cat爱吃小鱼干!!!");
}
//7.定义子类猫中的特有方法jump()
public void jump(){
System.out.println("小猫Cat跳的特别高@@@");
}
}
//3.子类狗,继承父类Animal
class Dog extends Animal{
}
4.2多态的使用
我们目前学习的多态对象都是把自己当做是一个父类类型,像花木兰替父从军一样,所以:
1).多态对象不可以使用子类特有的功能
2).多态对象使用的成员变量是父类的
3).多态对象使用时,如果父子类中出现同名静态方法,使用的还是父类的
4).多态对象在使用方法时,如果子类重写了,使用的是子类的方法体
TIPS:静态资源属于优先加载的类资源,静态方法不存在重写的现象
谁的对象来调用,就使用对应父类或者子类的静态方法
多态对象调用的静态方法是父类的,因为多态对象被看作是父类类型
目前学习的多态只是多态的其中一种,可以叫做向上型类
练习:多态中成员变量、普通方法、和静态方法的使用
package cn.tedu.oop;
/*本类用于多态中元素的测试*/
public class TestDemo2 {
public static void main(String[] args) {
//8.创建子类对象进行测试
Cat2 c =new Cat2();
System.out.println(c.sum);//100
c.eat();//子类对父类重写后的方法(功能)
c.play();//子类对象调用自己特有的方法
//9.创建多态对象进行测试
/*口诀1:父类引用 指向子类对象
* 口诀2:编译看左边,运行看右边*/
Animal2 a =new Cat2();
/*2.多态中,成员变量的使用都是父类的*/
System.out.println(a.sum);//10
/*3.多态中,方法的声明看的是父类的,实现使用的是子类的*/
a.eat();//小猫爱吃吃小鱼干!!
/*4.多态中如果父子类有同名的静态方法,使用的是父类的
*因为多态对象被看作是父类类型*/
a.play();//玩啥都行
}
}
//1.父类
class Animal2{
//3.成员变量-属性
int sum = 10;
//4.普通方法--行为功能
public void eat(){
System.out.println("吃啥都行~~~");
}
//10.创建父类中的静态方法
public static void play(){
System.out.println("玩啥都行");
}
}
//2.子类Cat2
/*多态的前提是:继承+重写*/
class Cat2 extends Animal2{
//5.成员变量--属性
int sum = 100;
//6.重写父类的普通方法eat()
@Override/*@Overtide是一个注解,加在方法上,表示这是一个重写的方法*/
public void eat(){
System.out.println("小猫爱吃吃小鱼干!!");
}
//7.定义子类独有的方法
//public void play(){
/*注意:静态资源属于类,不存在重写的现象
*只是两个类中恰好有两个同名的静态方法而已*/
public static void play(){
System.out.println("小猫爱玩逗猫棒###");
}
}
5.综合拓展
设计汽车综合案例
package cn.tedu.design;
/*本类用于完成OOP汽车设计综合案例*/
public class DesignCar {
public static void main(String[] args) {
//8.创建程序的入口函数main()方法
//创建父类对象进行测试
Car c = new Car();
System.out.println(c.getColor());//null需要使用get()/默认值
c.start();//父类自己的功能
c.stop();//父类自己的功能
//c.fly();//父类不能使用子类特有的功能
//9.创建一个宝马类对象
BMW b =new BMW();
System.out.println(b.color);//子类自己新定义的属性--五彩斑斓的黑
b.start();//没有重写,使用的是父类的功能--我的车车启动了~~
b.stop();//重写了,使用的是自己重写以后的功能--宝马当然要帅气的听的稳当些~~
//10.创建一个保时捷类的对象
BSJ b2=new BSJ();
System.out.println(b2.getColor());//null
System.out.println(b2.color);//黑不溜秋的白
b2.start();//使用的是继承过来的父类中的功能
b2.fly();//使用的是子类特有的功能
}
}
//1.通过归纳总结,使用关键字class抽象封装形成一个“类”组件来描述一类事物
class Car{
//2.属性--通过成员变量描述
//2.1属性的封装--通过关键字private对属性封装
private String brand;
private String color;
private double price;
private double size;//尺寸
//3.行为功能--通过普通方法描述
public void start(){
System.out.println("我的车车启动了~~");
}
public void stop(){
System.out.println("我的车车熄火了!!!");
}
//2.2给被封装的属性通过公共的属性值设置和访问方式--setxxx和getxxx
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public double getSize() {
return size;
}
public void setSize(double size) {
this.size = size;
}
}
//4.创建一个宝马类并且继承汽车类--关键字extends
class BMW extends Car{
String color = "五彩斑斓的黑";
//6.子类对父类方法不满意时可以重写父类的方法
//重写遵循两同两小一大原则,重写后,子类对象使用重写后的方法
@Override
public void stop(){
System.out.println("宝马当然要帅气的听的稳当些~~");
}
}
//5.创建一个保时捷类且继承汽车类--通过关键字extends建立继承关系
class BSJ extends Car{
String color = "黑不溜秋的白";
//7.新增子类特有功能
public void fly(){
System.out.println("保时捷的特有功能--飞行");
}
}