抽象类:
1)抽象类的概念:
针对一个事物,比如:动物类---->总体概括,之前定一个具体的动物(---->必须给他的某个功能只是声明即可),只有,猫或者狗等等这些才是具体事物
Java中,如果一个类中有一个方法声明(抽象方法)抽象功能,那么这个类定义为抽象类
关键字:abstract 抽象的意思
抽象类的特点:抽象类不能直接实例化!(不能创建对象) 接口也不能实例化
关于抽象类:
1.如果一个类中有抽象方法,那么这个类是一定是一个抽象类
2.抽象类必须有抽象方法吗? 抽象类中不一定都是抽象方法
抽象类的子类
1.如果子类是抽象类,没有意义,因为都不能实例化,对象如何创建
2.子类具体类,那么子类必须实现父类中的抽象功能
2) 抽象类的成员特点:
成员变量:
可以是变量,也是一个常量
构造方法:可以有无参,可以有有参,作用:给对象进行初始化的.
成员方法:可以有抽象方法,还可以有非抽象方法...
abstract和哪些关键字是冲突的,不能共有!
abstract 和private
abstract 和final
abstract和static
成员变量:
可以是变量,也是一个常量
构造方法:可以有无参,可以有有参,作用:给对象进行初始化的.
成员方法:可以有抽象方法,还可以有非抽象方法...
abstract和哪些关键字是冲突的,不能共有!
abstract 和private
abstract 和final
abstract和static
package org.westos.抽象练习;
public abstract class Employee {
private String name;
private int salary;
public Employee() {
}
public Employee(String name, int salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getSalary() {
return salary;
}
public void setSalary(int salary) {
this.salary = salary;
}
public void sleep() {
System.out.println("睡觉都打你妹的呼噜");
}
public abstract void work();
}
package org.westos.抽象练习;
public class Manager extends Employee{
int bonus;
public Manager() {
super();
// TODO Auto-generated constructor stub
}
public Manager(String name,int salary,int bonus) {
super(name,salary);
this.bonus=bonus;
}
/**
* @return the bonus
*/
public int getBonus() {
return bonus;
}
/**
* @param bonus the bonus to set
*/
public void setBonus(int bonus) {
this.bonus = bonus;
}
public void work() {
System.out.println("经理和客户吃饭喝酒谈生意");
}
public void by() {
System.out.println("经理开大奔上班");
}
}
public class Programmer extends Employee{
public Programmer() {}
public Programmer(String name,int salary) {
super(name,salary);
}
public void work() {
System.out.println("程序员没日没夜敲代码");
}
public void by() {
System.out.println("程序员挤地铁上班");
}
}
public class AbstractDemo {
public static void main(String[] args) {
Manager mag=new Manager("马云",3800,2000);
System.out.println(mag.getName()+"--"+mag.getSalary()+"--"+mag.getBonus());
mag.work();
mag.sleep();
mag.by();
Employee pro=new Programmer("刘强东",4000);
pro.work();
Programmer pro2=( Programmer)pro;
pro2.by();
pro=new Manager("马化腾",1000,2000);
}
}
接口:
1)接口:体现的是事务的扩展性功能(额外动作,后天经过学习等等)
接口格式(标识符:类,接口:见名知意)
interface 接口名{
//抽象功能
public abstract void jump() ;
}
接口的特点:不能实例化
接口的子实现类:实现类 (具体的实现类)
class 类名+impl implements 接口名{
}
接口的子类如果是抽象类:没有意义,不能实例化
接口多态(最多)
抽象类多态(比较多)
具体对象的创建(经常会使用)
interface AniamlTrain{
// public void show() {
//
// }
//接口中的方法不能有方法体,只能是抽象方法
public abstract void jump() ;
public abstract void speak() ;
}
interface Speak{
public abstract void speak() ;
}
class Cat{}
//子类是一个抽象类
//abstract class JumpCat implements AniamlTrain{
//
//
//}
//具体实现类
//class JumpCatImpl extends Cat implements AniamlTrain,Speak{
class JumpCatImpl extends Cat implements AniamlTrain{
@Override
public void jump() {
System.out.println("部分猫就可以跳高了...");
}
@Override
public void speak() {
System.out.println("猫开口说话了...");
}
}
public class Demo {
public static void main(String[] args) {
//接口多态
// AniamlTrain at = new JumpCat() ; //抽象类,和接口都不能实例化
//创建对象
AniamlTrain at = new JumpCatImpl() ;//接口多态(实际开发中用的最多)
at.jump();
at.speak();
}
}
1.成员变量:是一个常量,不能更改,并有默认字符修饰:public static final
2.构造方法:接口没有构造方法;
3.成员方法:接口的成员方法必须是抽象的,默认字符修饰:public abstract;
4.接口和接口之间的关系:继承关系,并且一个接口可以继承多个接口;
5.一个借口可以同时实现多个接口;
package org.westos.接口练习;
interface Inter{
int num=12;//默认public static final int num=12;
int num1=32;
void smoke();//默认public abstract void smoke();
}
interface Inter1{
void soccer();
}
//一个借口可以继承更多个借口
interface Inner2 extends Inter,Inter1{}
class Person{}
class Student extends Person implements Inter,Inter1{
public void smoke() {
System.out.println("学生抽烟没毛病老哥");
}
public void soccer() {
System.out.println("喜欢在球场上奔跑的感觉");
}
}
public class InterDemo {
public static void main(String[] args) {
Student st=new Student();
st.smoke();
st.soccer();
}
}
如果形式参数是接口:
传统的方式:1)提供给接口的子实现类
2)内部类的方式(不需要提供子实现类)
interface Inter2{
public abstract void study();
}
//具体类
class StudentDemo{
public void method(Inter2 i) {//Inter2 i = new Inter2() ;//错误
i.study();
}
}
class InterImpl2 implements Inter2{
@Override
public void study() {
System.out.println("好好学习,天天向上...");
}
}
//测试类
public class Demo {
public static void main(String[] args) {
//需求:需要调用StudentDemo这个类中method()方法
StudentDemo sd = new StudentDemo() ;
//接口多态的形式
Inter2 i = new InterImpl2() ;
sd.method(i);
System.out.println("---------------");
//链式编程:匿名对象
new StudentDemo().method(new InterImpl2());
System.out.println("----------------");
Inter2 i2 = new Inter2() {
@Override
public void study() {
System.out.println("好好学习,天天向上...");
}
};
i2.study();
}
}内部类:
1)内部类:在B类内部定义A类,A类就属于B类的内部类;
内部类访问外部类的特点:她可以直接访问外部类的成员,包括私有
外部类通过创建内部类的对象去访问内部类;
2)成员内部类:在外部类的成员位置;
局部内部类:在外部类的局部位置(方法中);
3)成员内部类 :可以直接访问外部类的成员,包括私有;
外部类访问内部类(非静态类)的成员方法的格式:
外部类名.内部类名 对象名=new 外部类名().new 内部类名();
4)关于内部类的修饰:
1. private:保障数据的安全性;
package org.westos.内部类;
//外部类
class Outer3{
//私有的内部类
private class Footballer{
public void ronaldo() {
System.out.println("罗哥效力于皇家马德里");
}
}
//调用私有内部类的方法
public void show(String name) {
if(name=="弗洛伦蒂诺") {
System.out.println("老佛爷在09年吧罗哥从曼联带到了20世纪最佳俱乐部");
//创建内部类对象
Footballer f=new Footballer();
f.ronaldo();
}
}
}
public class OuterDemo3 {
public static void main(String[] args) {
Outer3 o=new Outer3();
o.show("弗洛伦蒂诺");
}
}2.static:可以被静态内部类看成外部类的成员
特点:静态成员内部类访问外部类的成员,该成员必须是静态的
外部类访问静态内部类的成员方法的格式:
外部类名.内部类名 对象名=new 外部类名.内部类名();
class Outer4{
private int num = 10 ;
private static int num2 = 100 ;
//成员内部类:静态的
static class Inner4{
//成员方法
//非静态的内部类成员方法
public void show() {
//System.out.println(num); //静态成员内部类访问外部类的数据,该数据必须static修饰
System.out.println(num2);
}
//静态的内部类的成员方法
public static void show2() {
System.out.println(num2);
}
}
}
//测试类
public class OuterDemo4 {
public static void main(String[] args) {
//对于静态的成员内部类的访问格式
// 外部类名.内部类名 对象名 = new 外部类名.内部类名() ; //把静态的成员内部类看成了外部类的成员
Outer4.Inner4 oi = new Outer4.Inner4() ;
oi.show();
oi.show2();
}
}5)局部内部类:
1.可以访问外部类的成员包括私有...
2.在外部类的局部位置去访问内部类的方法,需要在局部位置创建内部类的对象,通过对象去访问 局部内部类访问局部变量,那么会出现问题?(jdk7以前包括jdk7,这个有问题的)
会报错,需要给局部变量添加final修饰...
为什么这个局部变量必须用final修饰?
//定义外部类
class Outer5{
private int num = 10 ;
//定义外部类的成员方法
public void method() {
//变量
final int num2 = 20 ; //jdk1.8不会有问题..
//定义局部内部类
class Inner5{
public void show() {
System.out.println(num);
//注意事项:在这块改变量继续被使用...将变量变成固定值:在内存始终存在(被内部类的成员去使用)
System.out.println(num2);
}
}
//创建对象
Inner5 i = new Inner5() ;
i.show(); //调用show()
}
}
public class OuterDemo5 {
public static void main(String[] args) {
//创建对象
Outer5 o = new Outer5() ;
o.method();
}
}
前提是有一个类或接口
这个类可以是具体类也可以是抽象类
格式:new 类名或接口名{
方法重写
}
匿名类的本质是继承了该类或者实现了该接口子类对象...
package org.westos.内部类;
//接口
interface Inter{
public abstract void show();
}
//外部类
class Outer2{
//成员方法
public void mathod(){
//实现接口子类对象
Inter i=new Inter(){
//方法重写
public void show() {
System.out.println("接口的方法已被重写");
}
};
//调用接口的方法
i.show();
}
}
public class OuterDemo2 {
public static void main(String[] args) {
Outer2 oi=new Outer2();
oi.mathod ();
}
}
形式参数和返回值的问题:
1)形式参数的问题:
形式参数是基本类型,对实际参数没有影响
形式参数是引用类型:类,接口,对实际参数有影响
package org.westos.形式参数和返回值的问题;
//接口
interface Person{
public abstract void show();
}
//子类实现接口
class Student implements Person{
public void show(){
System.out.println("好好学Java");
}
}
//
class PersonDemo{
//调用接口的方法
public void mathod(Person p) {
p.show();
}
}
public class PersonText {
public static void main(String[] args) {
PersonDemo pd=new PersonDemo();
//创建接口的子类实现对象
Person p=new Student();
pd.mathod(p);
}
}
2) 返回值:
如果返回值基本类型:用对应的基本类型去接收数据即可!
引用类型:
类(具体类): 需要的是该类的对象
抽象类:那么返回需要的结果是需要当前抽象类的子类对象 抽象类多态
接口:返回的是该接口的子类实现对象,接口多态
package org.westos.形式参数和返回值的问题;
//接口
interface Person2{
public abstract void show();
}
class PersonDemo2{
//调用接口的方法
public Person2 mathod() {
return new Person2() {
//方法重写
public void show() {
System.out.println("以后好好工作,累也得忍着");
}
};//创建接口的(匿名类)子类实现对象
}
}
public class PersonText2 {
public static void main(String[] args) {
PersonDemo2 pd=new PersonDemo2();
//抽象类多态
Person2 p=pd.mathod();
p.show();
}
}
1531
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
