对象与引用
Java 语言中除基本类型之外的变量类型都称之为引用类型。
Java中的对象是通过引用对其操作的.
例如:
class Car{
String color;
String name;
}
Car ad= new Car();
通常把这条语句的动作称之为创建一个对象,其实,它包含了三个动作。
1)右边的“new Car()”,是以Car类为模板,调用Car类的构造函数,在堆空间里创建一个Car类对象。
2)左边的“Car ad”创建了一个Car类型引用变量。所谓Car类的引用,就是以后可以用来指向Car对象的对象引用。
3)”=”操作符使对象引用指向刚创建的那个Car对象。
Car类加载在内存中 存放在方法区
new Car()在堆空间里创建一个Car类对象
static关键字
static被称为静态 用来修饰类的属性 方法 代码块 内部类
随着类的加载而加载
优先于对象存在
修饰的成员 被所有对象共享
直接被类调用
静态属性是类的所有对象共享的,不管创建了多少个对象,静态属性在内存中只有一个。
静态成员不能访问非静态成员
非静态成员可以访问静态成员
代码块
代码块在类中声明,类似一个没有名称的方法体(代码块),
代码块分实例块和静态块
实例块:每次创建对象时自动调用
{
//任何符合语法的Java代码
}
静态块:类加载时自动调用,仅一次,与是否创建对象无关。
static {
//任何符合语法的Java代码
}
package com.ff.day2;
/*
代码块 类似一个没有名称的方法体
实例块:每次创建对象时自动调用
静态块:类加载时自动调用,只调用一次,与是否创建对象无关
静态块 优先于 实例块执行
*/
public class SellTickect {
{
System.out.println("实例块1");
}
{
System.out.println("实例块2");
}
static{
System.out.println("静态块1");
}
static{
System.out.println("静态块2");
}
public SellTickect(){
System.out.println("text ");
}
public static void main(String[] args) {
new SellTickect();
}
}
/*输出结果
静态块1
静态块2
实例块1
实例块2
text */
包
包就是文件夹
包的作用
避免类重名
按照不同功能管理类
控制访问权限
package com.ff.day4;
import java.util.Date;
//import java.sql.Date;不允许导入两个类名相同的类
//import 类的地址 在一个类中使用另一个包的类 通过import关键字导入
//java.lang包的类在使用时不需要导入
public class Test {
public static void main(String[] args) {
Date a=new Date();
java.sql.Date b=new java.sql.Date(10);
String s="";
}
}
访问权限修饰符
public 公共权限 修饰类、属性、方法。可以被任意类访问
protected 受保护的权限 修饰属性、方法 可以被同包类访问,如果不是同包类,必须是该类的子类才可以访问。
(default)同包权限 修饰类、属性、方法。只能被同包的类访问
private私有权限 修饰属性、方法。 只能在本类中访问
封装
将类的某些信息隐藏在类内部 不允许外界
直接访问 而是通过该类提供的方法 来实现对隐藏信息的操作和访问
封装的好处
方便修改实现 方便加入控制语句 隐藏类的实现细节 只能通过方法访问
具体表现
属性使用private权限
方法使用public权限
public class Animal {
private String name;
private int age;
/*
将类的某些信息隐藏在类内部 不允许外界直接访问 而是通过该类提供的方法 来实现对隐藏信息的操作和访问
封装的好处
方便修改实现 方便加入控制语句 隐藏类的实现细节 只能通过方法访问
*/
public Animal() {
super();
System.out.println("animal的构造方法");
}
public void eat(){
System.out.println("吃");
}
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;
}
}
继承
继承是从已有的类中派生出新的类,新的类能吸收已有类的属性和行为,并能扩展新的能力
是实现代码可重用的根基,是提高代码可扩展性的主要途径
在JAVA中使用extends关键字来表示继承关系。
JAVA不支持多继承,单继承使JAVA的继承关系很简单,一个类只能有一个直接父类。
继承之后子类可以调用父类的所有非私有属性和非私有方法
当一个没有继承任何一个类时,jvm会默认让类继承Object类
Object是 java为所有类提供的基类
子类构造方法总是先调用父类构造方法,默认情况下调用父类无参构造方法
可以在子类构造方法的第一行,使用super关键字调用父类任意一个构造方法
如果用super,必须写在构造方法的第一句
public class Dog extends Animal{
private String whatDog;
public Dog() {
super();
System.out.println("dog 的构造方法");
}
public void wang(){
System.out.println("叫");
}
public String getwhatDog() {
return whatDog;
}
public void setwhatDog(String whatDog) {
this.whatDog = whatDog;
}
}
super
super关键字代表父类的引用,
在子类构造方法中要调用父类的构造方法,注意:super语句只能出现在子类构造方法体的第一行。
用“super.成员变量名”来引用父类成员变量
用“super.方法名(参数列表)”的方式访问父类的方法。
与this的区别,this通常指代当前对象,super通常指代父类。
重写
当父类的实现方式满足不了子类的需求时 重写
重写的条件
方法名 参数相同
子类的访问权限大于等于父类
返回值相同
构造方法 静态方法不能重写
public abstract class Animal {
//被abstract 修饰 没有方法体
public abstract void eat();
public abstract void sleep();
public Animal(){
}
public void paly(){
System.out.println("animal play");
}
}
public class Dog extends Animal{
public void eat() {
System.out.println("狗吃肉");
}
public void sleep() {
System.out.println("狗睡觉");
}
}
类之间的关系 关联依赖
has a 关联 当一个类的对象作为另一个类的属性存在是 关联
use a 依赖 当一个类的对象作为另一个类的方法存在时 依赖
public class Person {
// 封装:将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问
private String name;
private int age;
private Phone phone;//关联关系 一对一 Phone的对象 作为person的属性存在
private Phone[] phones;//关联关系 一对多
/*
this关键字代表自身类的对象
this关键字必须放在非静态方法里面
*/
//依赖关系 person类中的方法用到了另一个类Dog
public void eatWhat(Dog dog){
dog.eat();
}
public void setName(String name){
this.name=name;
}
public void setAge(int age){
this.age=age;
}
public int getAge(){
return age;
}
public String getName(){
return name;
}
}
抽象方法
抽象方法是一种特殊的方法:
只有声明,而没有具体的实现
抽象方法必须用abstract关键字进行修饰
抽象类,抽象方法,在软件开发过程中都是设计层面的概念。
也就是说,设计人员会设计出抽象类,抽象方法,
程序员都是来继承这些抽象类并覆盖抽象方法,实现具体功能。
/*
abstract的方法一定是抽象类
但抽象类不一定有抽象方法
在顶层类中 方法的实现与子类大多数不同 就可以在顶层类中的方法就定义为抽象方法
*/
public abstract class Animal {
//被abstract 修饰 没有方法体
public abstract void eat();
public abstract void sleep();
public Animal(){
}
public void paly(){
System.out.println("animal play");
}
}
接口
接口特性
1.接口不能实例化对象(无构造方法),但可以声明对象的引用。(多态性)
2.接口不是被类继承了,而是要被类实现,实现类必须重写接口的所有方法
3.一个类可以实现多个接口,但只能继承一个类。
4.接口是隐式抽象的,当声明一个接口的时候,不必使用abstract关键字。
5.接口中每一个方法也是隐式抽象的,默认为public abstract 。
6.接口中声明的属性默认为 public static final 的;
7.多个类可以实现同一个接口。
8.与继承关系类似,接口与实现类之间存在多态性。
9.一个接口能继承其它多个接口。
10.当类实现接口的时候,类要实现接口中所有的方法。否则,类必须声明为抽象的类。
接口存在的意义
java中一个类只能有一个父类,但接口可以实现多继承。
从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现。
接口的定义与使用
接口的定义:
[访问修饰符] interface 接口名称 [extends 其他的接口名1,….其他的接口名n] {
// 声明常量
// 抽象方法
}
接口的使用:
[访问修饰符] class 类名 implements 接口名1,接口名2……{ }
结合继承:
[访问修饰符] class 类名 extends 父类名 implements 接口名1,接口名2……{ }
package com.ff.day7;
/*
接口的定义
interface+接口名字{
成员变量都是public static final
所有方法都是 public abstract
}
*/
interface Imessage{
public static final String info="this is a message";
public abstract String getInfo();
}
interface IChannel{
public abstract boolean connect();
}
/*
接口的使用
class+ 类名+ implements+ 接口名1,接口名2……{
实现接口
}
*/
class Messageimpl implements Imessage,IChannel{
public String getInfo() {
if (this.connect()) {
return "发送得到一个秘密的消息,有人胖了。";
}
return "通道创建失败,无法获取消息。";
}
public boolean connect(){
System.out.println("消息发送通道已经成功建立。");
return true;
}
}
public class MyInterFace {
public static void main(String args[]) {
Imessage m = new Messageimpl();
System.out.println(m.getInfo());
}
}
final关键字
final 用于声明属性,方法和类
属性:定义就必须直接赋值或者在构造方法中进行赋值,并且后期都不能修改。
方法:子类里不可被覆盖。
类:不能被定义为抽象类或是接口,不可被继承。
package com.ff.day8;
//final 修饰的类不能被继承
/*
public final class FinalDemo {
*/
//final 用于声明属性,方法和类 参数
public class FinalDemo {
final static int num=0; //直接初始化常量 使用final对属性赋值时建议用static 在内存中只有一份
// final int count;
public FinalDemo() {
}
/* 在创建每一个对象时 对象中包含一个常量 必须在构造方法中赋值
public FinalDemo(int a) {
count=a;}
*/
public void test(final int b){
//参数中的值不能被修改 int b=5;
}
//被final 修饰的方法不能被重写
public final void eat(){
System.out.println("aaaaa");
}
}
多态
同一种事物,在不同时刻表现不同的状态
多态存在的三个必要条件
要有继承(包括接口的实现)(前提条件)
要有重写(前提条件)
父类引用指向子类对象
多态环境下对成员方法的调用 编译看左边,运行看右边。
多态环境下对静态成员方法的调用 编译和运行都看左边。
多态环境下对成员变量的调用 编译和运行都看等号左边。
方法参数具有多态性 好处:提高代码的扩展性
向上转型的作用是:提高程序的扩展性。
向下转型的作用是:为了使用子类中的特有方法。
package com.ff.dt;
public class Test1 {
public static void main(String[] args) {
//向上转型 父类类型表示所有子类 提高程序的可扩展性
Animal dog=new Dog();
Animal cat=new Cat();
Test1 t=new Test1();
t.feedAnimal(dog);
t.feedAnimal(cat);
}
/*
同一种事物,在不同时刻表现不同的状态
多态存在的三个必要条件
要有继承(包括接口的实现)(前提条件)
要有重写(前提条件)
父类引用指向子类对象
多态缺点 不能访问子类特有的成员方法
*/
public void feedAnimal(Animal animal){
animal.eat();
//向下转型 父类类型转换为子类类型
if (animal instanceof Dog){
Dog dog=(Dog) animal;
dog.play();
}
if (animal instanceof Cat){
Cat cat=(Cat) animal;
cat.catchMouse();
}
}
}