目录
一、类和类之间的关系
【1】面向对象的思想:找参与者,找女孩类,找男孩类
【2】体会了什么叫方法的形参,什么叫方法的实参:
需要传入的是形参:
具体传入的内容是实参:
【3】类和类可以产生关系
1.将一个类作为另一个类中的方法的形参
2.将一个类作为另一个类的属性
Boy类
package com.hhf.test03;
public class Boy {
//属性
int age;
String name;
//方法
public void buy(){
System.out.println("我给你买买买");
}
//构造器
public Boy() {
}
public Boy(int age, String name) {
this.age = age;
this.name = name;
}
}
Girl类:
package com.hhf.test03;
public class Girl {
//属性
String name;
double weight;
Mom m =new Mom();
//方法
public void love(Boy b){
System.out.println("我男朋友的名字是:"+b.name+"他的年龄是"+b.age);
b.buy();
}
public void wechat(){
m.say();
}
//构造器
public Girl() {
}
public Girl(String name, double weight) {
this.name = name;
this.weight = weight;
}
}
Mom类:
package com.hhf.test03;
odified By:
*/
public class Mom {
public void say(){
System.out.println("妈妈");
}
}
Test:
package com.hhf.test03;
public class Test {
public static void main(String[] args) {
//跟男孩谈恋爱
Boy b =new Boy(30,"蔡徐坤");
Girl girl=new Girl("迪丽热巴",50);
girl.love(b);
//还可以在微信跟妈妈聊天
// girl.m = new Mom();
girl.wechat();
}
}
二、final修饰符
1.修饰变量:
package finalStudy;
public class Test {
public static void main(String[] args) {
//【1】
//final修饰一个变量,变量的值不可以改变,这个变量也变成了一个字符常量,约定俗成的规定:名字大写
final int A = 10; //final修饰基本数据类型
//A = 10;报错,不可以修改
//【2】
final Dog d = new Dog(); //final修饰引用数据类型,那么地址值就不可以改变
//d = new Dog();——》地址值不可以改变
//d对象的属性依然可以改变
d.age=10;
d.weight=163.8;
//【3】
final Dog d2=new Dog();
a(d2);
//【4】
b(d2);
}
public static void a(Dog d){
d = new Dog();
}
public static void b(final Dog d){//d被final修饰,指向不可以改变
//d=new Dog();——》错误代码
}
}
2.修饰方法,final修饰方法,那么这个方法不可以被该类的子类重写:
3.修饰类;final修饰类,代表没有子类,该类不可以被继承;一旦一个类被final修饰,那么里面的方法也没有必要用final修饰了
4.案例:JDK提供的math类
1.使用math类的时候无需导包,直接使用即可
2.math类没有子类,不能被其他类继承了
3. 里面的属性全部被final修饰,方法也是被final修饰的,只是省略不写了。原因:子类没有必要进行重写
4.外界不可以创建对象:Math m=new Math();
5.发现math类中的所有属性,方法,都被static修饰,那么不用创建对象去调用,只能通过类名.属性名,类名.方法名 去调用
三、抽象类,抽象方法
1.抽象类和抽象方法的关系:抽象类中可以定义0-N个抽象方法。
2.抽象类作用:在抽象类中定义抽象方法,目的是为了为子类提供一个通用的模板,子类可以在模板的基础上进行开发,先重写父类的抽象方法,然后可以扩展子类自己的内容。
抽象类设计避免了子类设计的随意性,通过抽象类,子类的设计变得更加严格,进行某些程度上的限制。使子类更加的通用
3.代码演示:
package chouXiangLeiYuFangFa;
//4.一个类中如果有抽象方法,那么这个类也要变成一个抽象类.
//一个抽象类中可以有0-N个抽象方法
public abstract class Person {
//1.在一个类中,会有一类方法,子类对这个方法非常满意,无需重写,直接使用
public void eat() {
System.out.println("一顿不吃饿得慌");
}
//在一个类中,会有一类方法,子类对这个1方法永远不满足,会对这个方法进行重写
//3.一个方法的方法体去掉,然后被abstract修饰,那么这个方法就变成了有一个抽象方法
public abstract void say();
public abstract void sleep();
}
//6.抽象类可以被其他类继承:
//7.一个类继承抽象类,那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰,一般让子类重写父类中的抽象方法
//9.子类继承抽象类,就必须重写全部的抽象方法
//10.子类如果没有重写父类的抽象方法,那么子类也可以变成一个抽象类
class Student extends Person {
@Override
public void say() {
System.out.println("我是客家人,我讲客家话");
}
@Override
public void sleep() {
System.out.println("正午时分");
}
}
class Demo{
public static void main(String[] args) {
//11.创建抽象类的对象:————》抽象类不可以创建对象
// Person p = new Person();
//12.创建子类对象:
Student s=new Student();
s.say();
s.sleep();
//13.多态的写法:父类引用指向子类对象:
Person p = new Student();
}
}
4.面试题:
问:抽象类不能创建对象,那么抽象类中是否有构造器?
答:抽象类中一定有构造器。构造器的作用:给其他子类初始化对象的时候要先super调用父类的构造器。
问:抽象类是否可以被final修饰?
答:不能被final修饰,因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了,就不存在继承了,就没有子类
四、内部类
1.成员内部类:
package com.hhf.test07;
* 1.类的组成:属性,方法,构造器,代码块(普通块,静态块,构造块,同步块),内部类
* 2.一个类(TestOutter)的内部的类(SubTest)叫内部类,内部类:SubTest 外部类:TestOutter
* 3.内部类:成员内部类(静态的,非静态的) 和 局部内部类(位置:方法内,块内,构造器内)
* 4.成员内部类:
* 里面有属性,方法,构造器等
* 修饰符:private,default,protect,public,final,abstract
*/
public class TestOutter {
//非静态的成员内部类:
class D{
int age =20;
String name;
public void method(){
//5.内部类可以访问外部类的内容
/*System.out.println(age);//可以访问外面的属性
a();//可以调用外面的方法*/
int age =30;
//8.内部类和外部类重名的时候,如何进行调用:
System.out.println(age);//30
System.out.println(this.age);//20
System.out.println(TestOutter.this.age);//10
}
}
//静态成员内部类:
static class E{
public void method(){
//6.静态内部类中只能访问外部类中被static修饰的内筒
/*System.out.println(age);
a();*/
}
}
//属性:
int age=10;
//方法:
public void a(){
System.out.println("这是a方法");
{
System.out.println("这是一个普通块");
class B{
//局部内部类放在块中
}
}
class A{//局部内部类放在方法内
}
//7.外部类想要访问内部类的东西,需要创建内部类的对象然后进行调用
D d=new D();
System.out.println(d.name);
d.method();
}
static {
System.out.println("这是静态块");
}
{
System.out.println("这是构造器,先执行构造块,再执行构造器");
}
//构造器:
public TestOutter(){
class C{
//局部内部类放在构造器中
}
}
public TestOutter(int age) {
this.age = age;
}
}
class Demo{
public static void main(String[] args) {
//8.创建外部类对象
TestOutter to = new TestOutter();
to.a();
//9..创建内部类的对象:
//静态的成员内部类创建对象
TestOutter.E e=new TestOutter.E();
//非静态的成员内部类创建对象
//错误:TestOutter.D d=new TestOutter.D();
//正确
TestOutter t = new TestOutter();
TestOutter.D d=t.new D();
}
}
2.局部内部类:
package com.hhf.test08;
public class TestOuter {
//1.在局部内部类中访问到的变量必须是被final修饰的
public void method(){
final int num=10;
class A{
public void a(){
//num=20;
System.out.println(num);
}
}
}
//2.如果类B在整个项目中只使用一次,那么就没有必要单独创建一个B类,使用内部类就可以了
public Comparable method2(){
class B implements Comparable{
@Override
public int compareTo(Object o) {
return 1000;
}
}
return new B();
}
public Comparable method3(){
//3.匿名内部类
return new Comparable() {
@Override
public int compareTo(Object o) {
return 100;
}
};
}
public void test(){
Comparable com = new Comparable() {
@Override
public int compareTo(Object o) {
return 300;
}
};
System.out.println(com.compareTo("abc"));
}
}