JAVA基础10

JAVA基础10

抽象类

用abstract 修饰的类:

当我们父类的方法不需要方法体时,我们可以将我们的方法修饰成抽象的

​ 抽象方法格式:

​ abstract 修饰符 返回值类型 方法名(参数列表);

​ 抽象类的定义格式:

​ abstract class 类名{}

注意事项:

  1. 抽象类中可以没有抽象方法,有抽向方法的类一定是抽象类

  2. 抽象类不能创建对象,需要使用子类向上转型

    3.抽象类本身无意义,所以我们应该使用一个类去继承它,然后重写里面所有的

抽象方法,或者,这个子类本身也得是一个抽象类

  1. 抽象类有构造方法,本身无意义,但是可以给子类对象初始化,因为继承关系中,子类对象想要创建成功,必须到父类构造中走一圈

  2. abstract 不能和final共存,因为被final修饰的类不能被继承而abstract修饰的类必须被继承

如果想要使用抽象类中的对象,可以使用抽象类多态的形式

  • /**
    
    - 定义一个抽象类形状(Shape),包含两个方法,求周长和面积(抽象方法)
      定义一个类长方形,实现抽象类中的方法	(长,宽)	(构造方法)
      定义一个类圆,实现抽象类中的方法	(半径)	(构造方法)
      在测试类中测试
      	创建一个长方形和圆,分别求周长和面积
      	创建一个方法,既可以求圆的周长面积,也可以求长方形的周长和面积
       */
      public class AbstractTest2 {
      public static void main(String[] args) {
      	Shape r = new Rect(20,10);
      	/*System.out.println(r.getPrimeter());
      	System.out.println(r.getArea());*/
      	Shape c = new Circle(4);
      	/*System.out.println(c.getPrimeter());
      	System.out.println(c.getArea());*/
      	print(r);
      	print(c);
      }
      public static void print(Shape s) {
      	System.out.println("周长为:" + s.getPrimeter());
      	System.out.println("面积为:  "+ s.getArea());
      }
      }
      abstract class Shape{
      abstract public double getPrimeter();
      abstract public double getArea();
      }
      class Rect extends Shape{
      double length;
      double width;
      public Rect() {}
      public Rect(double length,double width) {
      	this.length = length;
      	this.width = width;
      }
      public double getPrimeter() {
      	return 2*(length+width);
      }
      public double getArea() {
      	return length*width;
      }
      }
      class Circle extends Shape{
      public static final double PI = 3.14;
      double r;
      public Circle() {}
      public Circle(double r) {
      	this.r = r;
      }
      public double getPrimeter() {
      	return 2*PI*r;
      }
      public double getArea() {
      	return PI*r*r;
      }
      }
    

继承关系和组合关系:

案例: 定义一个Person类,里面包含,姓名,年龄,性别和手机(品牌,型号,价格,颜色):

​ 创建一个对象: 张三,18,男,手机(华为,p20,1888,“黑色”)

public class PersonTest {
	public static void main(String[] args) {
		Person p = new Person();
		p.setName("张三");
		p.setAge(18);
		p.setGender('男');
		Mobile m = new Mobile();
		m.setBrand("华为");
		m.setType("p20");
		m.setColor("黑色");
		m.setPrice(1888);
		p.setMobile(m);
		p.show();
		
	Person p2 = new Person("李四",29,'女',new Mobile("小米","note8","白色",1000));
	p2.show();
}
}
/**

- 继承:  is   a    	Teacher  is   a 		Person

- 组合:  has  a 	Person   has  a			Mobile

- 聚合:  has  a 

- Person 和 Mobile 关系就叫做组合关系
  */
  class Person{
  private String name;
  private int age;
  private char gender;
  private Mobile mobile;//组合

  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 char getGender() {
  	return gender;
  }
  public void setGender(char gender) {
  	this.gender = gender;
  }
  public Mobile getMobile() {
  	return mobile;
  }
  public void setMobile(Mobile mobile) {
  	this.mobile = mobile;
  }
  public Person() {
  	super();
  }
  public Person(String name, int age, char gender, Mobile mobile) {
  	super();
  	this.name = name;
  	this.age = age;
  	this.gender = gender;
  	this.mobile = mobile;
  }

  public void show() {
  	System.out.println("姓名:"+name+",年龄:"+age+",性别:"+gender+",品牌:"+mobile.getBrand()+",型号"+mobile.getType()+",颜色:"+mobile.getColor()+",价格:"+mobile.getPrice());
  }
  }

class Mobile{
	private String brand;
	private String type;
	private String color;
	private double price;
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public String getType() {
		return type;
	}
	public void setType(String type) {
		this.type = type;
	}
	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 Mobile() {
		super();
	}
	public Mobile(String brand, String type, String color, double price) {
		super();
		this.brand = brand;
		this.type = type;
		this.color = color;
		this.price = price;
	}
	
}

接口

​ 接口interface : 叫做扩展功能

定义格式:

​ interface 接口名{}

​ 注意事项:

​ 1. 接口中只能定义常量,默认public static final修饰

​ 2. 接口中只能定义抽象方法(1.8之前) 默认是public abstract 修饰

​ 3. 接口不能创建对象,使用子类向上转型

​ 4. 接口的子类: 实现了接口的类 class 子类名 implements 接口1,接口2{}

​ 5. 接口的子类要么实现接口中所有的抽象方法要么自己是一个抽象类

​ 6. 一个类可以实现多个接口,并且可以在继承类的同时实现多个接口

​ 7. 接口中没有构造方法

​ 8. jdk8之后接口中可以定义已经实现的方法,但是必须使用static/default 修饰

​ 9. 接口不能实现接口,只能继承接口,并且可以多继承

​ class 子类名 implements 接口1,接口2{}

练习1:

​ 定义一个接口,定义两个抽象方法,写一个类实现该接口,并实现里面的方法,使用接口多态创建对象,并调用方法

/**

- . 定义一个接口InterA, 里面包含一个抽象方法,一个常量值a=100

- . 定义一个接口,InterB,继承接口InterA, 在写一个抽象方法

- . 定义个类Test, 

- . 定义一个类Demo  继承Test 并 实现  InterB,实现里面所有的抽象方法

- . 在测试类中,创建InterB 类型的变量,调用里面的方法
     */
     public class InterfaceTest {

  public static void main(String[] args) {
  	InterB b = new Demo();// 接口的多态
  	b.test();
  	b.test2();
  }

}
interface InterA{
	void test();
	int a = 100;
}
interface InterB extends InterA{
	public void test2();
}
class Test{
}
class Demo extends Test implements InterB{
	@Override
	public void test() {
		System.out.println("test");
	}
	@Override
	public void test2() {
		System.out.println("test2");
	}
}

练习2:

​ 编写一个抽象类Animal,抽象类中包括属性:name(String类型),抽象方法:speak()。

​ 编写一个宠物接口pet,接口中包括方法:eat()。

​ 再编写一个类cat,实现该接口和抽象类中的所有方法。

​ speat(): “miao, my name is xxx”

​ eat(): “I want to eat some fish”

​ 在main中进行测试,输出:
​ 给猫赋值一个名字,调用speak,eat 方法

public class InterfaceTest2 {
	public static void main(String[] args) {
		Pet p = new Cat();
		p.eat();
		//p.speak();//speak 并不存在与Pet接口中,所有他是子类中独有的方法,在多态的时候,调不了
		Animal a = new Cat("小花");
		a.speak();
		//a.eat();//不能调子中独有的
	}
}
//the type animal is already defined: 代表本包中已经有该名字的类: 换一个名: 建一个包
abstract class Animal{
	String name;
	abstract public void speak();
}
interface Pet{
	void eat();
}
class Cat extends Animal implements Pet{
	public Cat() {}
	public Cat(String name) {
		this.name = name;
	}
	@Override
	public void eat() {
		System.out.println("I want to eat some fish");
	}
	@Override
	public void speak() {
		System.out.println("miao, my name is "+name);
	}
}

带包编译

使用notepad++ 编写一个带包的HelloWorld

package com.doit.test;
class HelloWorld{
	public static void main(String[]args){
		
		System.out.println("hello world");
	}
}

使用命令行如何执行:

package com.doit.test;

手动式:

  1. 使用javac命令编译 javac 文件名.java javac HelloWorld.java

  2. 在类所在的文件夹下,按照包的格式把对应的文件夹创建出来,把.class文件拷贝到文件夹中

    ​ 使用java 包名.类名 运行

自动式:

  1. javac(空格) -d (空格).(空格) 文件名.java
  2. java 包名.类名

导包: import 全类名;

顺序: package import class

权限修饰符

public: 修饰类, 修饰变量和方法 , 权限最大,可以在任意包内调用

protected: 修饰变量和方法 , 当前包内 随意访问 ,跨包只能在继承过父类的子类中使用

(default)/package: 修饰类,变量,方法 , 只能在当前包内访问

private: 修饰方法和变量 , 只能在本类中访问

protected: 修饰方法和变量

​ 可以在不同包的子类中访问, 可以使用super关键字,创建子类的对象访问(创建父类的对象无法访问)

修饰外部类的修饰符:

​ public (default) final abstract

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值