1.this关键字
字面意思:
这个
1.一般写在 实体类中。表示的是当前的对象
可以使用 this调用 属性和方法
2.this关键字可以调用构造方法（很少用）
注意事项:
1.一定是在构造方法调用另外一个构造方法
2.在构造方法中调用其他的构造方法的时候，构造调用时候一定写在首行
1.1举例
package com.qf.test;
class Person {
String name;
int age;
public Person () {
System.out.println("Line 9： "+ this);//代表是当前的对象
this.name = "狗蛋";//this可以调用属性
}
public void eat () {
//this可以调用方法
this.test();
}
public void test () {
System.out.println("嘻嘻");
}
}
public class Demo1 {
public static void main(String[] args) {
Person person1 = new Person();
System.out.println(person1);//对象的内存地址 15db9742
System.out.println(person1.name);
person1.eat();
Person person2 = new Person();
System.out.println(person2);//对象的内存地址6d06d69c
System.out.println(person2.name);
}
}
1.2举例
package com.qf.test;
class Dog {
String name;
int age;
public Dog () {
//在无参构造方法中调用有参构造方法
//System.out.println("xixi");
//Constructor call must be the first statement in a constructor
this("旺财", 5);
System.out.println("xixi");
}
public Dog (String name) {
this();//调用无参的构造方法
this.name = name;
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
//一个参数的构造方法 去调用 无参构造方法 在无参构造方法调用了有两个参数的构造方法
public class Demo2 {
public static void main(String[] args) {
Dog dog = new Dog("二狗");
System.out.println(dog.name);//二狗
System.out.println(dog.age);// 5
//Dog dog = new Dog();
// dog.name = "大黄";
// dog.age = 4;
// Dog dog1 = new Dog("大黄", 6);
// System.out.println(dog1.name);
// System.out.println(dog1.age);
}
}
1.3举例
package com.qf.test;
class Dog {
String name;
int age;
public Dog () {
//在无参构造方法中调用有参构造方法
//System.out.println("xixi");
//Constructor call must be the first statement in a constructor
this("旺财", 5);
System.out.println("xixi");
}
public Dog (String name) {
this();//调用无参的构造方法
this.name = name;
}
public Dog(String name, int age) {
this.name = name;
this.age = age;
}
}
//一个参数的构造方法 去调用 无参构造方法 在无参构造方法调用了有两个参数的构造方法
public class Demo2 {
public static void main(String[] args) {
Dog dog = new Dog("二狗");
System.out.println(dog.name);//二狗
System.out.println(dog.age);// 5
//Dog dog = new Dog();
// dog.name = "大黄";
// dog.age = 4;
// Dog dog1 = new Dog("大黄", 6);
// System.out.println(dog1.name);
// System.out.println(dog1.age);
}
}
1.4举例
package com.qf.test;
class Student {
String name;
int age;
public Student() {
this.name = "张三";
this.age = 24;
}
public Student(String name, int age) {
this();//在有参的构造方法中调用了无参构造方法
this.name = name;
this.age = age;
}
}
public class Demo3 {
public static void main(String[] args) {
Student stu = new Student("狗蛋", 28);
System.out.println(stu.name);
System.out.println(stu.age);
}
}
2.方法的参数是一个类对象
方法的参数可以是八大基本数据类型 ， String , 数组
类对象也是作为方法的参数
人喂狗，狗吃饭
2.1举例
package com.qf.test;
class People {
//一个类对象可以作为一个方法的参数
public void feed (Dog1 dog1) {//这个是喂的方法
dog1.eat();
}
}
class Dog1 {
public void eat () {
System.out.println("狗去啃大骨头");
}
}
public class Demo4 {
public static void main(String[] args) {
People people = new People();
Dog1 dog1 = new Dog1();
people.feed(dog1);
}
}
练习： 老师教学生 学生敲代码
package com.qf.test;
class Teacher {
public void teach (Student1 stu) {
stu.coding();
}
}
class Student1 {
public void coding () {
System.out.println("敲代码");
}
}
public class Demo5 {
public static void main(String[] args) {
Teacher teacher = new Teacher();
Student1 student1 =new Student1();
teacher.teach(student1);
}
}
练习: 人生孩子，孩子去玩玩具 ，玩具被玩（在玩具类中打印玩具被玩）
package com.qf.test;
class Adult {//成年人类
public void birth (Child child) {
Toy toy2 = new Toy();
child.playToy(toy2);
}
}
class Child {
public void playToy (Toy toy) {
toy.bePlay();
}
}
class Toy {
public void bePlay () {//玩具被玩
System.out.println("被玩，很开心");
}
}
public class Demo6 {
public static void main(String[] args) {
Adult adult = new Adult();
Child child= new Child();
adult.birth(child);
}
}
3.多类合作
3.1 生活中的解释
一个类对象可以作为另外一个类的属性
人类：
属性：
名字 String
年龄 int
狗 Dog （属性）
狗类：
属性
名字
颜色
3.2举例
package com.qf.test;
class RenLei {//人类
String name;
int age;
BigDog bigDog;//bigDog这个对象带了三个数据 牛彩云 3 黑色
}
class BigDog {
String name;
int age;
String color;
}
public class Demo8 {
public static void main(String[] args) {
BigDog bd = new BigDog();
bd.name = "牛彩云";
bd.age = 3;
bd.color = "黑色";
RenLei renLei = new RenLei();
renLei.name = "二贝";
renLei.age = 38;
renLei.bigDog = bd;
System.out.println(renLei.name);
System.out.println(renLei.age);
//人的狗 狗的名字
System.out.println(renLei.bigDog);//内存地址
System.out.println(renLei.bigDog.name);// 牛彩云
System.out.println(renLei.bigDog.age);//3
System.out.println(renLei.bigDog.color);//黑色
}
}
4.继承【重点】
Java有三大特性: 封装 继承 多态
4.1生活中继承
子承父业
龙生龙 凤生凤 老鼠的儿子会打洞
4.2Java中继承
继承至少得两个类:
语法格式：
class A {
属性
方法
}
class B extends A {
B就可以继承你的属性和方法
}
入门案例:
package com.qf.test;
class Father {
//属性
String name;
int age;
//行为
public void eat () {
System.out.println("吃窝窝头");
}
}
class Son extends Father{//想让Son 去继承Father类
}
public class Demo9 {
public static void main(String[] args) {
Son son = new Son();
son.name = "大头";//儿子类中可以使用父类的属性
son.age = 15;
System.out.println(son.name);
System.out.println(son.age);
son.eat();
}
}
继承其实就是将父类的属性和方法，子类中可以使用
1.成员变量（属性）
公开的(public)和默认的(啥也不写)属性，子类是可以使用
私有的属性，子类是无法使用
2.成员方法（方法）
公开的(public)和默认的(啥也不写)方法，子类是可以使用的
私有的方法，子类是无法使用
3.构造方法
new Son1(); 尽管你是 new 的儿子类 但是会执行父类的构造方法
1.先执行父类的构造方法，然后再执行子类的构造方法
2.如果父类中没有无参构造方法，子类也不能有无参构造方法
package com.qf.test;
class Father1 {
//公开的和默认的属性可以被子类继承的
public String name;//公开的属性
int age;//默认的属性
private int id;//私有化的
public Father1 () {
}
public Father1(String name, int age, int id) {
this.name = name;
this.age = age;
this.id = id;
}
//公开的方法
public void eat () {
System.out.println("吃红薯面");
}
//默认的方法
void work () {
System.out.println("翻地球");
}
//私有话的方法 子类无法使用的e
private void smoking () {
System.out.println("抽旱烟");
}
}
class Son1 extends Father1{
public Son1 () {
}
public Son1(String name, int age, int id) {
super(name, age, id);//调用父类的有参构造方法
// TODO Auto-generated constructor stub
}
//mplicit super constructor Father1() is undefined. Must explicitly invoke another constructor
//父类中不存在，儿子的无参构造方法也不能存在
// public Son1 () {
// System.out.println("这个是子类的无参构造方法");
// }
//总结： 子类的构造方法必须依靠父类的构造方法的形似来进行创建
}
public class Demo10 {
public static void main(String[] args) {
Son1 son1 = new Son1();
son1.name = "小灰灰";//发现确实可以继承
son1.age = 17;//发现 默认的属性也是可以继承
//the field Father1.id is not visible 不可见
//son1.id = 12;
son1.eat();
son1.work();
//son1.smoking();
}
}
5.多类合作的扩展
package com.qf.test;
class Adult {//成年人类
String name;
int age;
//有一个孩子的属性
Child child;
}
class Child {//孩子类
String name;
//可以有玩具
Toy toy;
}
class Toy {//玩具类
String name;//玩具的名字
String kind;//玩具种类
double price;//玩具价格
}
public class Demo1 {
public static void main(String[] args) {
Toy toy = new Toy();
toy.name = "加特林";
toy.kind = "玩具枪";
toy.price = 200;
Child child = new Child();
//对child进行赋值
child.name = "小邢";
child.toy = toy;
Adult adult = new Adult();
//对adult进行赋值
adult.name = "老邢";
adult.age = 89;
//this.name = name;
adult.child = child;
//以上都是在赋值
//以下是取值
//让你通过成年人去获取玩具的价格
System.out.println("玩具的价格为:" + adult.child.toy.price);
}
}
package com.qf.test;
class Adult1 {//成年人类
private String name;
private Child1 child1;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Child1 getChild1() {
return child1;
}
//setChild1 的方法是一个类对象
public void setChild1(Child1 child1) {
this.child1 = child1;
}
}
class Child1 {//孩子类
private String name;
private Toy1 toy1;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Toy1 getToy1() {
return toy1;
}
public void setToy1(Toy1 toy1) {
this.toy1 = toy1;
}
}
class Toy1 {
private String name;
private double price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
public class Demo2 {
public static void main(String[] args) {
//无外乎就是对成员变量进行赋值和取值
Toy1 toy1 = new Toy1();
toy1.setName("挖掘机");
toy1.setPrice(78.9);
Child1 child1 = new Child1();
child1.setName("小小磊");
child1.setToy1(toy1);
Adult1 adult1 = new Adult1();
adult1.setName("骚磊");
//adult1.child = child;
adult1.setChild1(child1);
//以上是赋值
//取值
//通过成年人获取玩具的名字和价格
System.out.println(adult1.getChild1().getToy1().getName());
System.out.println("成年人的名字为:" + adult1.getName() + ",孩子名字是:" + adult1.getChild1().getName() + ", 孩子的玩具的名字为:" + adult1.getChild1().getToy1().getName() + ",价格为:" + adult1.getChild1().getToy1().getPrice());
}
}
就是对属性赋值和取值
6.继承
6.1继承有啥好处
代码重复利用
package com.qf.test;
class Father {
String name;
int age;
}
class Son1 extends Father{
}
class Son2 extends Father{
}
class Daughter1 extends Father{
}
class Daughter2 extends Father{
}
public class Demo3 {
public static void main(String[] args) {
}
}
6.2关于继承的概念
- B继承了A B叫A的子类 A叫B的父类 超类 基类 祖宗类
- Java中是单继承 （只能有一个父类） 但是可以多重继承
package com.qf.test;
class Father1 {
String name1;
}
class Father2 extends Father1{
String name2;
}
//Son 叫Father2 爹 Father2 叫 Father1 爹
//Son 叫Father1 爷爷 多重继承
class Son extends Father2 {
}
public class Demo4 {
public static void main(String[] args) {
}
}
6.3关于父类和子类的内存分析
关注 栈 和堆
class Father {
String name;
int age;
}
class Son extnds Father {
char sex;
}
main {
Son son = new Son();
}
无论是父类和子类都在堆中的 同一个内存空间中
7.重写和重载【重点】
7.1重写（override）
重写的目的： 和继承有关 重写的是方法 子类是可以继承父类的非私有化的方法的
但是有的时候父类的方法需求满足不了子类的需求了，这个时候在子类中需要重写父类的方法
package com.qf.test;
class Father3 {
public void eat () {
System.out.println("吃窝窝头");
}
}
class Son3 extends Father3{
/*
* //重写: 就是把父类的方法重新写一遍，就是内容不一样
* 父类的方法不能动，子类的方法重新写了一遍
* 除了方法体中的内容不一样，其他都是一样的
*
* 其他是啥：
* 1.方法的名字
* 2.方法返回值
* 3.方法的参数
*/
// public void eat (String name) {
// System.out.println(name + "吃大盘鸡");
// }
@Override //重写的严格限定 告知程序员 下面方法是重写的方法，不是自己独有的方法
public void eat() {
System.out.println("吃烤鸭");
}
}
public class Demo5 {
public static void main(String[] args) {
Son3 son3 = new Son3();
son3.eat();//调用的父类的方法
//son3.eat("狗蛋");//调用的是子类独有的方法
}
}
练习： 猴子类 （行为）叫 ， 吃 人类 吃 叫
package com.qf.test;
class Monkey {
public void shout () {//叫的方法
System.out.println("GIA哦");
}
public void eat () {
System.out.println("吃草");
}
}
class Human extends Monkey {
@Override
public void shout() {
System.out.println("我擦");
}
@Override
public void eat() {
System.out.println("吃兔兔");
}
}
public class Demo6 {
public static void main(String[] args) {
Human human = new Human();
human.eat();
human.shout();
}
}
重写规则：
1.必须有继承关系
2.在子类中去重写父类方法
3.父类的方法必须是公开的或者默认的方法
4.在子类中重写父类的方法除了方法体不太一样，其他都一样（方法的返回值， 方法的名字 ，方法的参数）
7.2重载（overload）
在Java中，同一个类中，有很多的方法，如果方法的名字一样，参数列表不一样，那么方法之间叫重载
重写规则：
1.方法的重载必须写在同一个类中
2.方法的名字的一样
3.方法的参数列表一定不一样
4.方法的返回值可以一样也可以不一样
5.无参构造方法和有参构造方法也是方法的重载
package com.qf.test;
import java.beans.IntrospectionException;
class Person {
public void eat () {
System.out.println("吃饭");
}
public void eat (String name) {
System.out.println(name + "吃黄焖酥肉");
}
public void eat (String kind, int a) {
System.out.println(kind + "吃 "+a+"份黄焖酥肉");
}
public int eat (int a) {
return a;
}
}
public class Demo7 {
public static void main(String[] args) {
}
}
8.super关键字【鸡肋】
食之无味弃之可惜
this:
代表当前的对象
1.this可以调用属性和方法
2.this可以调用构造方法
super:
代表是父类的对象
1.super可以调用属性和方法 【不太重要】
2.super可以调用父类的构造方法
package com.qf.superTest;
class Father {
String name;
int age;
public Father (String name, int age) {
this.name = name;
this.age = age;
}
public void eat () {
System.out.println("吃饭");
}
}
class Son extends Father{
//无参构造方法
public Son () {
//JVM 虚拟机会默认调用调用父类的无参构造方法
//super();//在子类的无参构造方法中去掉用了父类的无参构造方法
//在子类的无参的构造方法中 去默认调用 父类的无参的构造方法 现在没有 就报错
//
super("狗蛋", 12);//调用父类的有参的构造方法
//在一个构造方法中 能同时调用两个父类的构造方法吗？ 不能的 就意味着 super() 这个默认的
//无参构造方法就不再执行了
//总之: 子类的构造方法 在调用父类的构造方法的时候，一定要确保 父类中有此对应好的构造方法
}
public void test () {
super.name = "狗蛋";//调用父类的name变量
this.name = "二蛋";
super.eat();//调用父类的eat方法
}
}
public class Demo1 {
public static void main(String[] args) {
Son son = new Son();
//son.eat();
son.test();
}
}
ackage com.qf.superTest;
class Human {
String name;
int age;
public Human (String name) {
this.name = name;
System.out.println("这个是父类的HUman构造方法");
}
}
class Man extends Human{
public Man () {
//啥也没写 jvm会自动调用 父类的无参构造方法 super(); 无参构造方法父类是有的
//super();//写了的话， 能看到了 就是再调用父类的无参构造方法
//如果父类中没有无参的构造方方法的话，啥也没写 jvm会自动调用 父类的无参构造方法 super();
//但是此时没有无参构造方法，所以报错了
super("hehe");//去调用了父类的有参的构造方法，此时不再调用默认的父类的无参构造方法了
//总结”： 父类中有的可以调用，没有的就直接编译不通过，会报错的
}
}
public class Demo2 {
public static void main(String[] args) {
Man man = new Man();
System.out.println(man.name);//hehe
}
}
9.抽象类【重点】
在面向对象中，所有的对象都是可以通过类创建（描述的） 。反过来说并不是所有的类都能创建对象
如果一个类中没有足够的信息来描述一个对象的话，那么这个类叫抽象类
9.1抽象类声明
在Java中使用abstract修饰的类叫抽象类
在Java中使用abstract修饰的方法叫抽象方法
9.1语法格式
abstract class Person {
//正常类的属性
String name;
//普通的成员方法
public void eat () {
System.out.print("吃饭");
}
//抽象方法 没有方法体的方法 没有大括号的
public abstract void sleep ();
}
入门案例
package com.qf.abstractTest;
abstract class Person {//抽象类
//抽象类中可以有属性 方法 抽象方法
public void eat () {//普通方法
System.out.println("吃饭啊");
}
//声明一个抽象方法 abstract 修饰符
//是一个不完整的方法， 完整方法应该带方法体
public abstract void test (int a);
}
//The type Man must implement(实现) the inherited abstract method Person.test()
//在普通类中 Man中，必须可以实例化的。所以Man所有的信息都要时完整的
//必须去重写 父类中 抽象的方法
class Man extends Person{
@Override
public void test(int a) {//是重写的 抽象的类的抽象方法
System.out.println( a + "这个是子类重写的的抽象父类的抽象的方法");
}
}
public class Demo1 {
public static void main(String[] args) {
//抽象类不能创建对象 咋办？ 只能 被继承
// Person person = new Person();
Man man = new Man();
man.eat();
man.test();
}
}
9.2抽象类的详解
1.如果一个类中有抽象方法，那么这个类一定是抽象类
2.抽象方法是一个没有方法体的方法，是一个不完整的方法
3.抽象类中能有普通方法吗？ 可以
4.抽象类能被实例化吗？ 不能
5.抽象类不能被实例化，然后可以使用普通类去继承抽象类
6.在子类中 必须去重写父类的所有的抽象方法，让抽象方法变得有意义
7.在抽象类中，非抽象的方法能不能在子类被重写的，可以的
8.一个抽象类可以继承另外一个抽象类
9.一个抽象类也可以继承一个非抽象的类
package com.qf.abstractTest;
class Cell {
}
abstract class Monkey1 extends Cell{
public abstract void shout();//叫的方法
}
abstract class Person1 extends Monkey1{
public abstract void run();
// public abstract void jump() {//使用abstract修饰的方法 一定不要带方法体
//
// }
public void sing() {
System.out.println("唱歌");
}
}
//普通类Man1要去重写它爹，和它爷 和他祖宗的所有的抽象方法
class Man1 extends Person1 {
@Override
public void run() {
// TODO Auto-generated method stub
System.out.println("撒丫子跑路");
}
@Override
public void sing() {
System.out.println("嗷嗷叫");
}
@Override
public void shout() {
// TODO Auto-generated method stub
System.out.println("嘎嘎乱叫");
}
}
public class Demo2 {
public static void main(String[] args) {
//Person1 person1 = new Person1();
}
}