今天我又来了呀!
今日~份下面这些可能对你有用哦!
最近我们学习类面向对象,刚开始觉得还可以,挺好学的,比如向,什么是类,类的组成,继承,封装,多态等等…
还有几种关键字:this,super,setxxx/getxxx,abstract,interface等等…就让我一一说道哈.
类
定义类对象应具有的特征贺行为,类是对象的模板.
对象
拥有多个特征和行为的实体,对象是类的实例.
什么是封装?
将类的属性私有化,保证数据的安全性;对外提供公共的访问方法
private关键字的特点
private:
可以修饰成员变量,也可以修饰成员方法,只能在本类中访问,外界不能访问!
但是可以间接的通过公共的方法来访问!
面向对象思想特点
1)更符合生活中思想行为习惯
2)角色发送变化了:从执行者变成指挥者
3))让复杂的事情简单化!
class Person{
static {
System.out.println("Person的静态代码块!");
}
public Person(){
System.out.println("Person的构造方法");
}
{
System.out.println("Person的构造代码块");
}
}
class Student extends Person{
static {
System.out.println("Student的静态代码块!");
}
public Student() {
System.out.println("student的构造方法");
}
{
System.out.println("student的构造代码块");
}
}
public class ExtendsTest3 {
public static void main(String[] args) {
Student s = new Student() ;
Student s2 = new Student() ;
}
}
2. 代码块
局部代码块:在局部位置:{} 方法定义中定义的{},
作用:限定局部变量的声明周期
构造代码块:类的成员位置,{}
作用:就给类中属性数据初始化
静态代码块 :
```java
格式:
static{
//业务...
}
优先级:
静态代码块(只执行一次!) > 构造代码块 > 构造方法
面向对象三大特征之一:继承 extends
继承的概念:
将多个类的共性内容抽取出来放在独立的类中,让着多个类和当前类产生一种关系,extends:继承关系．
继承的好处和特点
好处:
1)提高了代码的复用性
2)提高了代码的维护性
3)类和类之间的继承关系,是多态的前提条件!
特点:
1)Java中,对于类与类之间的只支持单继承,不支持多继承
2)但是,可以多层继承
继承中成员变量的关系问题: 遵循"就近原则":
1)先在子类的局部位置找,如果有就使用
2)如果没有,在子类的成员位置找,有就使用
3)如果没有,在父类的成员位置找,有就使用
4)如果父类没有,说明就没有这个变量,报错了!
继承中构造方法的访问问题:
子类的所有构造方法,默认父类的无参构造方法;
如果父类中没有给出无参构造方法,子类构造方法报错,
1)手动给出父类无参构造方法
2)通过super(xxx):访问父类的有参构造方法
3)通过在子类的有参构造方法中通过this()访问本类的无参构造方法,
然后在通过本类的无参构造方法里面:super(xxx)访问父类的有参构造方法
继承中成员方法的关系问题:
子类的成员方法名和父类的成员方法名一致(一模一样)
方法重写:
子类继承父类,子类出现了和父类一摸一样的方法,称为方法覆盖,复写/重写.. (Override)
让我们来说一下this和super的区别:
this:代表当前类对象的地址值引用
super:代表父类的空间标识(理解为父类的对象的地址值引用)
访问区别
this.变量名:当前类的成员变量
super.变量名:访问的父类的成员变量
this.方法名:当前类的成员方法
super.方法名:父类的成员方法
this():访问当前类的无参构造方法
super():访问父类的无参构造方法
this(xx):访问当前类的有参构造方法
super(xx):访问父类的有参构造方法
有关方法重写和方法重载的区别?
方法重写:
子类继承父类,子类出现了和父类一摸一样的方法,称为方法覆盖,复写/重写.. (Override)
方法重载:
定义方法的时候,方法名相同,参数列表不同,与返回值无关 (Overload)
什么是多态,多态的前提条件以及成员访问特点?
多态:一个事物在不同时刻体现的不同状态(堆内存中的变化)
多态的前提条件:
1)必须有继承关系
2)存在方法重写
3)父类引用指向子类对象
Fu f = new Zi();
多态的成员访问特点:
成员变量:编译看左,运行看左边
成员方法:(非静态的成员方法):编译看左,运行看右边:存在方法重写
静态的方法:编译看左,运行看左边(静态算不上方法重写,直接跟类相关的!)
构造方法:由于存在继承关系,还需要分层初始化(构造方法目的:对数据进行初始化!)
形式参数是引用数据类型具体的类,那么实际参数需要传递的是什么?
class Student{
public void xx(){
...
}
}
class StudentDemo{
public void method(Student s){
s.xx() ;
}
}
调用方法的时候,实际参数需要传递该具体类的对象!
static,final,private三者之间的区别?
static关键字的特点
1)随着的类加载而加载,加载一次
2)优先于对象存在----->在static中不能够有this的
3)可以被多个对象共享,共有
4)被static修饰的变量,方法,访问方式类名.变量名/类名.方法名();
final关键字的特点
final:状态修饰符,最终的,无法更改的!
final修饰类,该类不能继承
final修饰变量,该变量此时一个常量!
final修饰成员方法,该方法不能被重写!
finally:处理程序异常的时候,
try...catch...finally(一般情况:释放资源(相关系统资源)):标准格式(捕获异常)
private关键字的特点
表示私有的,外界不能够访问的,保证数据的安全性!
可以修饰成员变量/成员方法,都只能在本类中方法,但是可以通过公共的方法间接访问!
public,private,protected(受保护的),默认修饰符 (前两个使用居多)
多态
一个事物在不同时刻体现的不同状态(堆内存中的变化)
多态的前提条件:
1)必须有继承关系
2)存在方法重写
3)父类引用指向子类对象
Fu f=new Zi();
多态的成员访问特点:
成员变量:编译看左,运行看左边
成员方法:(非静态的成员方法):编译看左,运行看右
多态的弊端:不能访问子类的特有功能
向上转型:多态的基本格式: Animal a = new Cat();
向下转型:将父类的引用强制转换为子类的引用
Cat c = (Cat)a;//相当于Cat c = new Cat() ;
然后做了以下总结:
1.如何通过外部类访问成员内部类的成员方法
成员内部类:
如果是非静态的
外部类名.内部类名 对象名 = 外部类对象.内部类对象;
是静态内部类的
外部类名.内部类名 对象名 = new 外部类名.内部类名();
后面讲集合中(迭代器---->成员内部类)
2.形式参数如何是类,接口,抽象类,实际参数如何传递
方法的返回值是类,接口,抽象类,如何返回
形式参数是引用类型
如果是类(具体类):调用方式实际参数需要传递该类的具体对象
如果是抽象类:实际参数需要传递该抽象类的子类对象
如果是接口:实际参数需要传递该接口的子实现类对象
返回值是引用类型
如果是类(具体类):返回该类具体对象
如果是抽象类:需要返回该抽象类的子类对象
如果是接口:需要返回该接口的子实现类对象
3.面向对象的三大特征是什么?
封装,继承,和多态
4.面向对象思想特点
1)更符合生活中的思想行为习惯
2)角色变化,从执行者变成指挥者
3)让复杂的事情简单化
举例:...
5.多态的成员访问特点
成员变量:编译看左,运行看左边
成员方法:编译看左,运行看右:存在方法重写
静态方法:编译看左,运行看左:静态跟类直接相关
构造方法:数据进行分层初始化(父类初始化完毕,然后子类初始化)
6.重写和重载的区别
重写:子类继承父类,在子类中出现了和父类一模一样的方法...
重载:方法名相同,形式参数列表不同,与返回值无关
package com.eclipse_1;
/*
*
* 子类继承父类,关于构造方法的问题
* 子类不能继承父类的构造方法,但是可以通过super间接访问父类的构造方法
*
* 子类的所有构造方法默认访问父类的无参构造方法!
* 为什么要访问父类的无参构造方法?
*
* 构造方法的目的:就是为了数据初始化
* 由于存在继承关系,创建的是子类对象,对子类初始化的时候(执行构造方法),可能会用到父类的数据,必须
* 要让父类先进行初始化(先执行父类的构造方法),父类初始化完毕了,才是子类初始化(分层初始化!)
*
* 注意:每一个子类的构造方法中的第一句话
* 默认存在super() ; 可以不写(隐藏的)
*
* super:代表父类的空间标识(代表父类对象的地址值引用)
*
*
* */
//父类
class Fu{
//提供一个父类的无参构造方法
public Fu() {
System.out.println("这是Fu的无参构造方法...");
}
}
//子类
class Zi extends Fu{
//子类的无参构造方法
public Zi() {
super() ;//默认的,可以不写
System.out.println("这是Zi的无参构造方法...");
}
//子类的有参构造方法
public Zi(String name) {
//super() ;//默认的,可以不写
System.out.println("这是Zi的有参构造方法...");
}
}
//测试类
public class Demo_1 {
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi() ;
System.out.println("-----------------------");
Zi zi2 = new Zi("高圆圆") ;
}
}
package com.eclipse_1;
/*
* 猫狗案例
*
* */
//测试类
public class Demo_2 {
public static void main(String[] args) {
Demo_4 d1=new Demo_4();
d1.setName("英短");
d1.setAge(5);
d1.setColor("可爱蓝");
System.out.println(d1.getName()+"---"+d1.getAge()+"---"+d1.getColor());
d1.catchMouse();
d1.playGame();
System.out.println("-----------------------------------------------");
//方式2:有参构造方法赋值
Demo_4 d2=new Demo_4("tom猫", 3, "橘黄色") ;
System.out.println(d2.getName()+"---"+d2.getAge()+"---"+d2.getColor());
d2.catchMouse();
d2.playGame();
System.out.println("-----------------------------------");
demo_5 d3=new demo_5();
d3.setName("道吉");
d3.setAge(5);
d3.setColor("白色");
System.out.println(d3.getName()+"---"+d3.getAge()+"---"+d3.getColor());
d3.palyGame();
d3.lookDoor();
System.out.println("-----------------------------------------------");
Demo_4 d4=new Demo_4("哈士奇", 3, "灰色") ;
System.out.println(d4.getName()+"---"+d4.getAge()+"---"+d4.getColor());
System.out.println("-----------------------------------");
d3.palyGame();
d3.lookDoor();
}
}
package com.eclipse_1;
public class Demo_3 {
private String name;
private int age;
private String color;
//这是父类的无参构造
public Demo_3() {
super();
}
//这是父类的有参构造
public Demo_3(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
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 String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
}
package com.eclipse_1;
public class Demo_4 extends Demo_3 {
public Demo_4() {
super();
// TODO Auto-generated constructor stub
}
public Demo_4(String name, int age, String color) {
super(name, age, color);
// TODO Auto-generated constructor stub
}
//特有功能
public void catchMouse() {
System.out.println("猫抓老鼠...");
}
public void playGame() {
System.out.println("猫可以玩毛线...");
}
package com.eclipse_1;
public class demo_5 extends Demo_3 {
public demo_5() {
super();
// TODO Auto-generated constructor stub
}
public demo_5(String name, int age, String color) {
super(name, age, color);
// TODO Auto-generated constructor stub
}
//特有功能
public void palyGame() {
System.out.println("狗拆家...");
}
public void lookDoor() {
System.out.println("狗看门...");
}
}
package com.eclipse_2;
/*
* 方法重载(Overload)方法重写(Override)的区别?
* 方法重载;
* 方法名相同,参数类别不同,与返回值无关
* 参数个数
* 参数类型
* 方法重写:
* 子类继承父类的时候,子类出现了和父类一模一样的方法...(方法覆盖,方法复写)
* */
//以前的手机
class Phone{
//打电话的功能
public void call() {
System.out.println("手机可以打电话了");
}
}
class NewPhone extends Phone{
//一个功能:将父类的功能覆盖掉
//@Override;jdk提供一个注解:说明当前这个方法是否是重写父类的方法
public void call() {
//延用以前的手机可以打电话的功能
super.call();
System.out.println("手机可以看天气预报了....");
}
}
public class Demo_2 {
public static void main(String[] args) {
//创建子类对象
NewPhone np=new NewPhone();
np.call();
}
}
package com.luoliang_abstract_1;
//这是一个很典型的抽象类abstract;
public class Manager extends Employee {
public String hh;
public Manager() {
super();
// TODO Auto-generated constructor stub
}
public Manager(String name, int gong, int zi,String hh) {
super(name, gong, zi);
// TODO Auto-generated constructor stub
this.hh=hh;
}
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("谈业务...");
}
}
package com.luoliang_abstract_1;
abstract class Employee {
public String name;
public int gong;
public int zi;
public Employee() {
super();
// TODO Auto-generated constructor stub
}
public Employee(String name, int gong, int zi) {
super();
this.name = name;
this.gong = gong;
this.zi = zi;
}
public abstract void work() ;
}
package com.luoliang_abstract_1;
public class Programmer extends Employee {
public String gzu;
public Programmer() {
super();
// TODO Auto-generated constructor stub
}
public Programmer(String name, int gong, int zi,String gzu) {
//super(name, gong, zi);
// TODO Auto-generated constructor stub
this.gzu=gzu;
}
@Override
public void work() {
// TODO Auto-generated method stub
System.out.println("程序员正在工作...");
}
}
package com.luoliang_abstract_1;
public class ceshi {
public static void main(String[] args) {
Employee e=new Programmer();
Programmer p=(Programmer)e;
p.work();
Employee e2=new Manager();
Manager m=(Manager)e2;
m.work();
}
}
在给你们吧猫狗案例优化一下:用接口来实现:
package com.luoliang_InterfaceDemo_1;
/*
接口类
*/
public interface Jump {
public abstract void jumping();
}
package com.luoliang_InterfaceDemo_1;
public abstract class Animal {
public String name;
public int age;
public String color;
public Animal() {
super();
// TODO Auto-generated constructor stub
}
public Animal(String name, int age, String color) {
super();
this.name = name;
this.age = age;
this.color = color;
}
/**
* @return the name
*/
public String getName() {
return name;
}
/**
* @param name the name to set
*/
public void setName(String name) {
this.name = name;
}
/**
* @return the age
*/
public int getAge() {
return age;
}
/**
* @param age the age to set
*/
public void setAge(int age) {
this.age = age;
}
/**
* @return the color
*/
public String getColor() {
return color;
}
/**
* @param color the color to set
*/
public void setColor(String color) {
this.color = color;
}
public abstract void eat();
public abstract void sleep();
}
package com.luoliang_InterfaceDemo_1;
public class Cat extends Animal {
public Cat() {
super();
// TODO Auto-generated constructor stub
}
public Cat(String name, int age, String color) {
super(name, age, color);
// TODO Auto-generated constructor stub
}
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("猫吃老鼠...");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("猫躺着睡觉...");
}
}
package com.luoliang_InterfaceDemo_1;
public class Dog extends Animal {
public Dog() {
super();
// TODO Auto-generated constructor stub
}
public Dog(String name, int age, String color) {
super(name, age, color);
// TODO Auto-generated constructor stub
}
@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("狗吃狗粮...");
}
@Override
public void sleep() {
// TODO Auto-generated method stub
System.out.println("狗趴着睡...");
}
}
package com.luoliang_InterfaceDemo_1;
public class JumpCat extends Cat implements Jump {
@Override
public void jumping() {
// TODO Auto-generated method stub
System.out.println("猫跳桌子...");
}
public JumpCat() {
super();
// TODO Auto-generated constructor stub
}
public JumpCat(String name, int age, String color) {
super(name, age, color);
// TODO Auto-generated constructor stub
}
}
package com.luoliang_InterfaceDemo_1;
public class JumpDog extends Dog implements Jump {
@Override
public void jumping() {
// TODO Auto-generated method stub
System.out.println("狗急跳墙...");
}
public JumpDog() {
super();
// TODO Auto-generated constructor stub
}
public JumpDog(String name, int age,String color) {
super(name, age,color);
// TODO Auto-generated constructor stub
}
}
package com.luoliang_InterfaceDemo_1;
//测试类
public class ceshi {
public static void main(String[] args) {
JumpCat c1=new JumpCat("蓝短",2,"蓝色");
System.out.println(c1.getName()+"----"+c1.getAge()+"----"+c1.getColor());
c1.eat();
c1.sleep();
c1.jumping();
System.out.println("---------------------------------------------------------");
JumpDog d1 = new JumpDog("大黄",3,"黄色");
System.out.println(d1.getName()+"----"+d1.getAge()+"----"+d1.getColor());
d1.eat();
d1.sleep();
d1.jumping();
}
}
内部类另一种形式:
局部内部类:在局部位置中定义的类
局部内部类的成员可以直接访问外部类的成员,包括私有
外部类成员方法如何访问局部内部类的成员?
在当前外部类的成员方法中,只需要创建内部类对象调用它的方法
匿名内部类:
它是内部类的一种简化格式
没有具体类名
格式:
new 类名(抽象类类名)/接口名(){
重写方法…
};
举例:
new Person(){ //Person:抽象类
//重写方法
public void love() {
…
}
} ;
- 匿名内部类的本质就是继承该抽象类或者实现了该接口的子实现类对象!
package zhomuo_liamxi_2;
/*
* 匿名内部类:
*
*
*
*
*
* 它是内部类的一种简化格式
* 没有具体类名
*
* 格式:
* new 类名(抽象类类名)/接口名(){
*
* 重写方法....
* };
* 举例:
* new Person(){ //Person:抽象类
* //重写方法
* public void love() {
* ...
* }
* } ;
*/
interface Inter{
//定义抽象方法
//如果接口中有两个抽象方法
public abstract void show();
public abstract void show2();
}
class Outer{
public void method() {
/*
* 匿名内部内的格式
* new 类名(具体类名/抽象类类名)/接口名(){
* 重写方法....
* }
*
* */
//接口的匿名内部内类-->相当于接口的实现类
//接口中只有一个抽象方法的调用
/*
new Inter() {
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("show...");
}
@Override
public void show2() {
// TODO Auto-generated method stub
System.out.println("show2...");
}
}.show();
*/
//上面代码调用非常麻烦:当前new 接口名(){}:接口的子类实现类对象分别调用方法
//给new 接口名(){}起对象名来访问方法
Inter i=new object() {
@Override
public void show() {
// TODO Auto-generated method stub
System.out.println("show...");
}
@Override
public void show2() {
// TODO Auto-generated method stub
System.out.println("show2...");
}
};
i.show();
i.show2();
}
}
package zhomuo_liamxi_2;
public interface object extends Inter {
}
//测试类
public class OuterDemo_1 {
public static void main(String[] args) {
Outer outer=new Outer();
outer.method();
}
}
这个程序我一直一直在想,始终报错,太难了我,然后我就一步一步来分析,还是出来了.哈哈哈,惊不惊喜意不意外。
好了这一期的学习就到这，下期再见~
扫一扫
4万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
