JAVA第三周小结（上）

wei_5guang_

已于 2023-04-01 20:58:33 修改

阅读量72

点赞数

文章标签： java

于 2023-03-18 14:35:11 首次发布

本文链接：https://blog.csdn.net/wei_5guang_/article/details/129636236

版权

1.This关键字

字面意思:

这个

1.一般写在实体类中。表示的是当前的对象

可以使用 this调用属性和方法

2.this关键字可以调用构造方法（很少用）

注意事项:

1.一定是在构造方法调用另外一个构造方法

2.在构造方法中调用其他的构造方法的时候，构造调用时候一定写在首行

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);
	}
}

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);
		
		
	}
}

2.方法的参数是一个类对象

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);
	}
}

3.多类合作

一个类对象可以作为另外一个类的属性

人类：

属性：

名字 String

年龄 int

狗 Dog （属性）

狗类：

属性

名字

颜色

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);//黑色
        
        
    }
}

多类合作的扩展

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);
	}
}

4.继承【重点】

继承至少得两个类:

语法格式:

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();
		
		
		
		
		
	}
}

关于继承的概念

B继承了A B叫A的子类 A叫B的父类超类基类祖宗类
Java中是单继承（只能有一个父类）但是可以多重继承4.2

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) {
		
	}
}

4.2 重写和重载【重点】

重写（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("狗蛋");//调用的是子类独有的方法
	}
}

总结：

重写的规则：

1.必须有继承关系
2.在子类中去重写父类方法
3.父类的方法必须是公开的或者默认的方法
4.在子类中重写父类的方法除了方法体不太一样，其他都一样（方法的返回值，方法的名字，方法的参数）

重载（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) {
		
	}
}

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();
	}
}

5 抽象类【重点】

在Java中使用abstract修饰的类叫抽象类

在Java中使用abstract修饰的方法叫抽象方法

语法格式:

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();
	}
}

5.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();
	}
}

6.final关键字

final：

字面意思: 最终的最后的意思修饰符

用法：

1.final可以修饰成员变量

final修饰的成员变量必须初始化（赋值），一旦被赋值之后，就无法被修改

2.final可以修饰局部变量

final修饰的局部变量可以暂时不用赋值，使用的时候必须赋值，一旦赋值以后就不能改了

3.final可以修饰成员方法

final修饰的方法不能被子类重写

4.final可以修饰类

final修饰的类不能被继承

5.final可以修饰对象的引用

这个引用一旦被赋值就无法被修改

package com.qf.b_final;

 class Person {
	final String name = "狗蛋";
	
	public void test () {
		final int a;//可以修饰局部变量的
		a = 20;
		//a = 30; final 修饰的局部变量一旦被赋值   无法被修改 
		System.out.println(a);
	}
	//final修饰的成员方法 无法被
	public final void  eat () {
		System.out.println("嘻嘻  中午不想出去吃饭了");
	}
}
//class Man extends Person {
//	//Cannot override the final method from Person
	@Override
	public void  eat () {
		System.out.println("嘻嘻 hehe");
	}
//}
public class Demo1 {
	public static void main(String[] args) {
		 final Person person = new Person();//Person person  对象的引用
		 System.out.println(person);//15db9742
		Person person1 = new Person();
		System.out.println(person1);//6d06d69c
		
		
		//将person1赋值person
		//person = person1;
		System.out.println(person);//6d06d69c
		//The final field Person.name cannot be assigned
		//person.name  = "二狗";
	}
}

7.接口【重点】

语法格式:

interface 接口的名字 {
属性
方法
}

package com.qf.c_interface;

interface USB {//接口的语法格式
	//Abstract methods do not specify a body   抽象的方法的不能有一个方法体
	public   void  connection();
	//接口下面的方法都是抽象的方法 是默认的抽象的方法
	
}
//接口无法被实例化 那咋办？   只能写一个普通类去实现（implements） 接口
class Computer implements USB{
	
	
	public void coding () {
		System.out.println("敲代码");
	}

	@Override
	public void connection() {
		System.out.println("连接u盘");
		
	}
}
public class Demo1 {
	public static void main(String[] args) {
		Computer computer = new Computer();
		computer.coding();
		computer.connection();
	}
}

接口的详解

语法格式:

1.使用关键字 interface来声明Java中的接口

2.接口下面是可以有属性的，只不过属性必须赋值，因为默认带了 public static final 表示的是常量

3.接口下面的方法都是抽象方法，尽管没有带abstract 默认也是public的

4.接口下面是一般都是抽象方法有特殊的情况呢jdk1.8之后，增加了可以使用default修饰的方法是可以带有方法体的

5.接口下面没有构造方法，就意味无法实例化

6.用一个普通类去实现（implements）接口

7.实现接口的时候一定要重写所有的抽象的方法，默认的方法可以重写也可以不写

8.一个类可以实现（implements）多个接口写法 implements D, C,F

9.一个接口可以去继承（extends）另外一个接口

package com.qf.c_interface;


interface C {
	void play();
}
//1.使用interface关键字来声明一个接口
interface A  extends C{
	//The blank final field name may not have been initialized
	//默认对属性 加了final修饰    默认加了static   默认也加了public
	public final static  String name = "狗蛋";//  使用 final static  修饰的量叫  常量（不可以改变的量）
	//接口下面可以常量  但是很 少
	int age = 20;
	
	
	void eat();//public   abstract 修饰的
	void sleep();
	
	default void test () {//和普通方法是一模一样的  如果不写 default 就报错  语法格式！！！
		System.out.println("测试默认方法");
	}
}
class B implements A{//一个类中可以实现多个接口

	@Override
	public void eat() {
		
		System.out.println("吃口香糖");
	}

	@Override
	public void sleep() {
		
		System.out.println("坐着睡");
	}

	@Override
	public void play() {
		// TODO Auto-generated method stub
		
	}

	
	
}
public class Demo2 {
	public static void main(String[] args) {
		//A  a= new A();不能实例化接口
		B b = new B();
		b.eat();
		b.sleep();
		b.test();
	}
}

wei_5guang_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA第三周小结（上）

1.This关键字字面意思:这个1.一般写在实体类中。表示的是当前的对象可以使用 this调用属性和方法2.this关键字可以调用构造方法（很少用）注意事项:1.一定是在构造方法调用另外一个构造方法2.在构造方法中调用其他的构造方法的时候，构造调用时候一定写在首行。
复制链接

扫一扫