1)随着类的加载而加载
2)优先于对象存在: 它不能this共存 (this:代表当期类对象的地址值引用)
对象还没有new的时候,当前被static修饰的成员就已经内存了
3)被静态修饰的 可以被多个对象共享:有共享共用的意思
举例:
饮水机中的水(适合)
水杯共享(不适合!)
4)被静态修饰的变量,方法----->静态变量或者静态方法
我们所说的成员变量和成员方法:都指的是非静态
静态的成员的访问方式:类名.变量
类名.方法名()
//定义一个类
class Demo{
//定义一个非静态变量
public int num = 100 ;
//静态变量
public static int num2 = 50 ;
//非静态成员方法
public void method(){
System.out.println("method demo...");
}
//静态的方法
public static void function(){
System.out.println("function demo...");
}
}
//测试类
public class StaticDemo {
public static void main(String[] args){
//访问Demo类中num变量
Demo d = new Demo() ;
System.out.println(d.num);
// System.out.println(d.num2); //以后这种方式不要出现
//被静态修饰的直接可以通过类名.静态变量名
System.out.println(Demo.num2);
System.out.println("---------------------------");
//访问Demo类中method的方法
d.method();
// d.function(); //不推荐这样方法:因为function静态
Demo.function();
}
}
1)非静态的方法既可以访问静态变量,也可以访问非静态的变量
既可以调用静态方法,也可以调用非静态方法
2)静态的方法:只能访问静态变量,
只能调用静态方法
简单记:静态只能访问静态
/**
* 定义一个Person类
*/
class Person{
String name ;//姓名
int age ; //年龄
//String country ;//国籍
static String country ;//国籍 (类变量:这种变量随着类的加载而加载,优先于对象存在!)
//提供无参
public Person(){}
//提供有参
public Person(String name,int age,String country){
this.name = name ;
this.age = age ;
this.country = country ;
}
public Person(String name,int age){
this.name = name ;
this.age = age ;
}
//提供一个show方法显示人的信息
public void show(){
System.out.println("当前这个人的姓名是:"+name+",年龄是:"+age+",以及国籍是:"+country);
}
}
//测试类
public class PersonDemo {
public static void main(String[] args){
//创建四个人:古代四大美女
Person p1 = new Person("西施",25,"中国") ;
p1.show();
System.out.println("----------------------------");
// Person p2 = new Person("貂蝉",26,"中国");
Person p2 = new Person("貂蝉",26);
p2.show();
System.out.println("-----------------------------");
// Person p3 = new Person("杨玉环",28,"中国") ;
Person p3 = new Person("杨玉环",28) ;
p3.show();
System.out.println("-----------------------------");
// Person p4 = new Person("王昭君",23,"中国") ;
Person p4 = new Person("王昭君",23) ;
p4.show();
//System.out.println(Person.country) ;
}
}
如果当前这个变量能够描述现实世界事物的属性的时候,这个时候变量就应该定义成员变量,否则局部变量
在开发中,尽量采用局部变量:范围小:方法结束,变量从内存消失
针对某个类,加入一些文档注释
@author 作者
@version 代码版本
@since 后面指定JDK版本号
以及每一个方法上加入文档注释
方法中有参数@param 参数名称 对参数进行解释说明的文字
方法中如果有返回值@return 对返回的结果进行解释说明
产生文档(document)--html页面
打开dos控制台
进入指定目录下:
javadoc -d 文件夹名称 -author -version java文件(xxx.java --ArrayTool.java)
//这就针对数组操作的工具类
/**
* 这个类是针对数组操作的工具类,里面提供了数组的遍历,获取数组中的最大值,以及提供冒泡排序,
* 以及查询数组中的某个元素的索引值的功能...
*
* @author yang
* @version V1.0
* */
public class ArrayTool {
//工具类中一般构造方法私有化的:一般是不让外界直接去new(创建实例)
private ArrayTool(){}
//printArray是ArrayTool的成员方法
//这个类中的所有的成员方法加入static
/**
* 这个功能是数组的遍历功能,最终遍历的结果形式为[元素1, 元素2, 元素3, ...]
* @param arr 它是针对指定的数组进行遍历
* */
public static void printArray(int[] arr){//ArrayDemo类的成员方法
System.out.print("[") ;
for (int i = 0; i <arr.length ; i++) {
//判断
if(i==arr.length-1){
System.out.println(arr[i] +"]");
}else{
System.out.print(arr[i]+", ");
}
}
}
/***
* 这个功能是针对数组获取最大值
* @param arr 在指定的数组中查询
* @return 最终返回的就是数组中的最大值
*/
public static int getMax(int[] arr){
//参照物
int max = arr[0] ;
//遍历其他元素
for(int x = 1 ; x < arr.length ; x ++){
if(arr[x] > max){
max = arr[x] ;
}
}
return max ;
}
/***
* 这个功能是针对数组查询数组中某个元素的索引值
* @param arr 在指定的数组中查询
* @param key 要查找的指定元素
* @return 返回结果就是的索引值,如果找不到,则返回-1
*/
public static int getIndex(int[] arr,int key){
//假设法
int index = -1 ;
for(int x = 0 ; x < arr.length ; x ++){
if(key == arr[x]) {
index = x ;
break ;
}
}
return index ;
}
/***
* 这个功能是针对数据进行冒泡排序,最终数组是一个有序的
* @param arr 针对指定的数组进行排序
*/
public static void bubbleSort(int[] arr){
for(int x = 0 ; x < arr.length-1; x ++){
for(int y = 0 ; y < arr.length-1 -x ; y ++){
//判断
if(arr[y] > arr[y+1]){
int temp = arr[y] ;
arr[y] = arr[y+1] ;
arr[y+1] = temp ;
}
}
}
}
}
在Java中,使用{}包裹棋起来的内容,成为代码块!
分类:
局部代码块 :在方法定义中使用 ,作用:限定局部变量的生命周期
构造代码块:在类的成员位置(类中,方法外),使用{}包裹起来 作用:给类中的一些成员进行数据初始化
特点:每次在执行构造方法之前,如果存在构造代码块,先执行构造代码块中的内容!
静态代码块:
在类的成员位置,直接使用 static{},特点:随着类的加载而加载,优先于对象存在!
作用:也可以通过static代码块,对一些操作(后期IO流创建文件/JDBC(Java链接数据库注册驱动))
静态代码块就加载一次!
优先级:
静态代码块 > 构造代码块 > 构造方法
//看程序写结果
/*
* 考点:
* 代码块的优先级
* 静态代码块 >构造代码块 > 构造方法
*
* 静态代码块:先执行,而且就执行一次!(因为类就加载一次!)
* */
class Student{
public Student(){
System.out.println("Student的无参构造方法");
}
{
System.out.println("Student的构造代码块");
}
public Student(String name){
System.out.println("Student的有参构造方法");
}
static{
System.out.println("Student的静态代码块");
}
}
public class Test {
static{
System.out.println("高圆圆42了,我很伤心");
}
public static void main(String[] args) {
System.out.println("我是main方法");
Student s = new Student() ;
Student s2 = new Student("高圆圆") ;
}
}
/*
高圆圆42了,我很伤心
我是main方法
Student的静态代码块
Student的构造代码块
Student的无参构造方法
Student的构造代码块
Student的有参构造方法
*/
//看程序,写结果
class Root {
static {
System.out.println("Root的静态初始化块"); //1)
}
{
System.out.println("Root的普通初始化块"); //4)
}
public Root() {
System.out.println("Root的无参数的构造器");//5)
}
}
class Mid extends Root {
static {
System.out.println("Mid的静态初始化块");//2)
}
{
System.out.println("Mid的普通初始化块");//6)
}
public Mid() {
//super();
System.out.println("Mid的无参数的构造器");//7)
}
public Mid(String msg) { //"hello"
this(); //访问的是本类的无参构造方法
System.out.println("Mid的带参数构造器,其参数值:" + msg);//8)
}
}
class Leaf extends Mid {
static {
System.out.println("Leaf的静态初始化块");//3)
}
{
System.out.println("Leaf的普通初始化块"); //9)
}
public Leaf() {
super("hello"); //显示访问父类的有参构造方法
System.out.println("Leaf的构造器");//10)
}
}
public class LeafTest {
public static void main(String[] args) {
new Leaf();//匿名对象
}
}
将多个类的共性内容抽取到一个独立的类中,然后这多个类和独立的这个类产生一种关系: 继承关系!
关键字: extends
class Fu{}
书写格式 :class Zi extends Fu{}
继承的好处:
1)提高代码的维护性!
2)提高代码的复用性!
3)类和类之间产生的关系,是多态的前提条件
程序开发中:遵循设计原则
开闭原则
接口分离原则
迪米特原则
依赖注入原则
....
这些设计原则都要遵循一个原则 "低(松)耦合,高内聚"(重点)
实际开发中:耦合避免不了,但是可以降低(类与类之间的关系越少越好!)
内聚:就是解决某件事件的能力!(一个类的能完成的事情,尽量一个类完成,不要产生过多的关系一块完成!)
降低耦合性:就可以通过反射(后期:贯穿于整个JavaEE核心技术)来创建某个类的实例!
1)类与类之间的关系,继承关系,只支持单继承
格式
class 子类名 extends 父类名{}
在有的语言里面,是支持多继承的 (Java中不支持这种写法)
class 子类名 extends 父类名1,父类名2,..{}
2)虽然不能支持多继承,但是可以支持多层继承!
//多层继承
class GrandFather{
public void method(){
System.out.println("我是爷爷...");
}
}
class Father extends GrandFather{
/* public void method(){
System.out.println("我是爷爷...");
}*/
public void show(){
System.out.println("shou Father...");
}
}
//单继承
class Son extends Father{
public void function(){
System.out.println("function son...");
}
}
//多继承:类与类之间不支持
//class Son extends Father ,Mother{
//}
1)子类继承父类:可以继承父类的非私有的成员,私有的成员外界不能访问的,只能在本类中访问
但是可以通过公共方法间接访问!
2)构造方法是不能被继承的,但是子类可以间接通过 super关键字访问父类的构造方法
一个类的组成
成员变量
构造方法
成员方法
成员变量
a)子类继承父类,如果子类中的成员变量名称和父类的成员变量名称不一致,分别访问即可!
b)子类继承父类,如果子类的成员变量名称和父类的成员变量名称一致:如何访问呢? (重点)
1)首先在子类的局部位置找,是否存在局部变量名称,如果有,就使用
2)如果没有,就在子类的成员位置找,是否存在这个变量,如果存在,就使用
3)如果在子类的成员位置中没有找到,直接在父类的成员位置中找,如果有,就是使用!
4)如果父类的成员位置都没有,就没有这个变量,报错!
遵循一个原则:就近原则!
1)子类继承父类,子类的所有的构造方法都会默认的访问父类的无参方法
子类的所有构造方法的第一句话:默认隐藏了super() ; 因为子类中肯能会使用到父类的数据,所以在继承关系中
得先让父类初始化---->构造方法 : 分层初始化!(先父类无参构造方法,在执行子类的构造方法)
super:代表的父类对象的空间表示(父类对象的地址值引用!)
//父类
class Fu{
// private String name ;
// private int age ;
//父类的无参构造方法
public Fu(){
System.out.println("Fu的无参构造方法...");
}
public Fu(String name){
System.out.println("Fu的有参构造方法...");
}
}
//子类
class Zi extends Fu{
public Zi(){
// super() ;//隐藏一个关键字super() ; 访问父类的无参构造方法
System.out.println("Zi的无参构造方法");
}
public Zi(String name){
// super() ;
System.out.println("Zi的有参构造方法");
}
}
//测试类
public class ExtendsDemo {
public static void main(String[] args) {
//创建子类对象
Zi zi = new Zi() ;
System.out.println("------------------------");
//有参构造创建对象
Zi zi2 = new Zi("hello") ;
}
}
/*
Fu的无参构造方法...
Zi的无参构造方法
------------------------
Fu的无参构造方法...
Zi的有参构造方法
*/
2)如果父类中的无参构造方法没有,子类会怎么样?
子类的所有的构造都会报错! (因为子类所有构造方法默认父类的无参构造方法!)
如何解决呢?
方式1:手动给出父类的无参构造方法(推荐)
方式2:在子类的构造方法中的第一句话:通过super(xxx),间接的访问父类的有参构造方法
方式3:只要子类的所有构造方法中一个能够让父类初始化即可!
在子类的构造方法中:this(xxx):---->访问本类的构造方法,然后再子类的构造方法中间接访问父类的有参构造方法super(xxx) ;
//父类
class Father{
//父类的无参构造方法
/* public Father(){
System.out.println("Fu的无参构造方法...");
}*/
public Father(String name){
System.out.println("Fu的有参构造方法...");
}
}
//子类
class Son extends Father{
public Son(){
super("随便给") ;
System.out.println("Zi的无参构造方法");
}
public Son(String name){
// super("随便给") ;
this() ;//访问本类的无参构造方法
System.out.println("Zi的有参构造方法");
}
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
Son s = new Son() ;
Son s2 = new Son("高圆圆") ;
}
}
/*
Fu的有参构造方法...
Zi的无参构造方法
Fu的有参构造方法...
Zi的无参构造方法
Zi的有参构造方法
*/
总结:this和super 的区别
this:代表的当前类对象的地址值引用
super:代表的父类对象的地址值引用(代表父类的空间标识)
访问成员变量
this.变量名; 访问的本类中的成员变量
super.变量名; 访问的是父类的成员变量
访问构造方法:
this() ; 访问本类的无参构造方法
super() ;访问的父类的无参构造方法
this(xxx);访问的本类的有参构造方法
super(xxx);访问的父类的有参构造方法
成员方法:
this.方法名();访问的是本类的成员方法
super.方法名() ;访问的是父类的成员方法
重写:如果子类出现了和父类一模一样的方法声明,叫做方法重写!(Override) ---方法复写(覆盖)
重写的目的:子类有自己的功能,需要将父类的该功能覆盖掉!
重写权限
当前子类继承父类的时候,如果存在方法重写,那么子类重写父类该方法访问权限不能更低!
要么跟父类的方法保持一直,要么带上public(推荐跟父类的方法一直即可!)
//定义一个手机类 :Phone
class Phone{
//打电话
public void call(){
System.out.println("手机可以打电话...");
}
}
//新的手机类
class NewPhone extends Phone{
//子类出现了和父类一模一样的方法声明:沿用打电话的功能,并且还需要提供新的功能
//@Override :标记当前这个方法是重写父类的方法 (JDK提供的内置注解)
public void call(){
System.out.println("可以看天气预报了...") ;
//沿用父类的功能
super.call();
System.out.println("还可以听音乐...") ;
}
}
//测试类
public class ExtendsDemo2 {
public static void main(String[] args) {
//创建子类对象
NewPhone np = new NewPhone() ;
np.call();
}
}
面试题:
方法重写和方法重载的区别?
方法重载: 在一个类中,提供n多个功能,这些功能,方法名相同,参数列表不同,与返回值无关(目的:提高某个功能的扩展性)
参数列表不同:
1)类型不同
2)个数不同
3)考虑参数类型的顺序
public static void open(int a,double d){}
public static void open(double a,int b){}
构造方法也可以重载!
方法重写:
在继承关系中,子类出现了父类一模一样的方法声明,重写的目的:子类有自己的功能,需要将父类的该功能覆盖掉!
举例:
动物:
都具备吃和睡的功能
猫和狗都继承自动物类,他们吃的不一样的
猫和狗就需要讲吃和睡的功能覆盖掉...
猫具体吃鱼
狗具体吃肉
final(状态修饰符):最终的,无法更改的
关于final关键字的特点:
1)可以修饰类,该类不能被继承!
2)可以修饰符成员方法,成员方法不能重写! (根据具体的题意要求!)
3)可以修饰的变量,这个变量此时是一个常量! (自定义常量)
class Fu2{
public int num = 20 ;
public final int num2 = 30; //就是 不能更改的变量: 值永远是30 (自定义常量)
public final void method(){
System.out.println("method Fu2...");
}
}
//定义一个子类
class Zi2 extends Fu2{
/*public void method(){
System.out.println("method Zi2...");
}*/
//子类自己的功能
public void show(){
final int num3 ; //被final修饰的局部变量:可以先定义,但是必须在使用前初始化,只能赋值一次
num3 = 40 ;
System.out.println(num3);
// num3 = 50 ;
}
}
//测试类
public class FinalDemo2 {
public static void main(String[] args) {
//创建子类对象
Zi2 zi2 = new Zi2() ;
zi2.method();
System.out.println("--------------------");
zi2.num = 100 ;
System.out.println(zi2.num);
//zi2.num2 = 50 ; //被final修饰的变量,只能赋值一次,不能再次赋值!
System.out.println(zi2.num2);
zi2.show();
}
面试题:
final ,finally,finalize()的区别?
final的关键字描述以及的三个特点
finally:处理异常用到 try...catch...finally(后面讲)
finalize():跟垃圾回收器有关系:回收内存中没有更多引用的对象(后面在讲常用类使用以下)
final修饰变量,此时变量是一个常量
变量:普通变量
final int a = 10 ;
实例变量
final Student s = new Student() ;
final修饰基本数据类型和引用类型的区别?
final修饰基本数据类型: 基本数据类型的对应的数据值不能在被赋值了,只能赋值一次!
final修饰引用类型:引用数据类型对应的地址值不能被改变
final Student s = new Student() ;//修饰实例变量s,s的堆内存地址值永远是固定值!
s = new Student() ;//重新开辟空间(报错)
开发中书写常量:
都使用public static final int a = 100 ;
public:访问权限足够大
static:可以被类名直接访问
final:这个变量是一个常量
class Constant{
public static final int a = 100 ; //自定义常量
public static final Student s = new Student() ;
//成员位置定义的:静态实例变量
}
Constant.a:类名.变量名;
多态:一个事物在不同时刻不同形态
举例:
现实世界事物 :水
气态,固态,液态
程序世界:
在内存中的变化
猫是动物 Animal a = new Cat() ;
猫是猫: Cat c = new Cat() ;
1)必须存在继承关系 (extends)
2)必须存在方法重写
子类需要覆盖父类的功能
Animal
eat():"动物都需要吃饭..."
Cat
eat() "猫吃鱼"
Dog
eat() "狗吃骨头"
3)必须有父类引用指向子类对象
class Fu{}
class Zi extends Fu{
//存在重写
}
格式: Fu fu = new Zi() ;
Fu fu = new Zi() ;
1)针对成员变量的访问问题:
编译看左,运行看左!(使用父亲的东西)
2)针对多态中的成员方法的访问问题: 我们所说的成员变量/成员方法----非static
编译看左,运行看右(因为子类重写了父类的东西)
3)如果成员方法是静态方法:(静态成员方法 算不上方法重写,直接可以类名来访问,跟类相关的方法)
编译看左,运行看左
4)构造方法:
存在继承关系: 还需要让父类先构造初始化,然后再子类进行构造初始化!(分层初始化!)
//动物类
class Animal{
int age = 10 ;
public void eat(){
System.out.println("动物饿了就需要吃饭...");
}
public Animal(){
System.out.println("Animal的无参构造方法");
}
//父类的静态show
public static void show(){
System.out.println("show animal...");
}
}
//猫类
class Cat extends Animal{
int age = 3 ;
public Cat(){
System.out.println("Cat无参构造方法");
}
public void eat() {//猫吃鱼
System.out.println("猫吃鱼");
}
//子类的静态show
public static void show(){
System.out.println("show Cat...");
}
}
//测试类
public class DuoTaiDemo {
public static void main(String[] args) {
//使用多态来进行测试
//父类引用指向子类对象
// 格式: Fu fu = new Zi() ;
Animal a = new Cat() ;
System.out.println(a.age);
a.eat();
// a.show() ;//静态方法当然推荐这种访问
// Animal.show();
//Cat.show();
}
}
1)提高代码的复用性:由继承保证
2)提高了代码的扩展性:由多态保证 (重点)
Fu fu = new Zi() ; 父类引用可以指向子类对象
//有一个动物类
class Animal2{
//吃和睡
public void eat(){
System.out.println("动物饿了,都需要吃饭...");
}
public void sleep(){
System.out.println("动物困了,都需要休息...");
}
}
//两个子类
class Cat2 extends Animal2{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫趴着睡觉");
}
}
class Dog2 extends Animal2{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void sleep() {
System.out.println("狗侧着睡觉");
}
}
//定义一个动物类的工具类:AnimalTool
class AnimalTool{
//构造方法私有:不让外界new
private AnimalTool(){}
//父类引用可以指向子类对象:形式参数就可以传递Animal2
public static void createAnimal(Animal2 a){ // Animal2 a = new Dog2();
a.eat(); //多态的成员方法访问问题
a.sleep();
}
}
//测试类
public class DuoTaiDemo2 {
public static void main(String[] args) {
//具体的动物类创建对象
//喜欢狗--创建一只狗
Dog2 d = new Dog2() ;
d.eat();
d.sleep();
//创建第二只
Dog2 dd = new Dog2();
dd.eat();
dd.sleep();
System.out.println("----------------------");
//创建猫
Cat2 c = new Cat2() ;
c.eat();
c.sleep();
//第二只猫
Cat2 cc = new Cat2() ;
cc.eat();
cc.sleep();
System.out.println("=============================================");
//上面的问题:随着类型的增加(猴子,猪,大象...),不但提供的对应类型还需要通过createXXX(XXX 类型)
//继续优化:单独定义一个动物类的工具类AnimalTool(构造方法私有化,提供对外的静态功能)
// AnimalTool.createDog(new Dog2());
//AnimalTool.createCat(new Cat2());
//代码:只是将两个功能封装到一个工具类AnimalTool中,随着动物类型不断增加,createXXX()不断增加
//形式参数传递的是一个父类,父类引用指向子类对象
AnimalTool.createAnimal(new Dog2()); //Animal2 a = new Dog2() ;
AnimalTool.createAnimal(new Cat2()); //Animal2 a = new Cat2() ;
}
}
不能访问子类的特有功能 (Fu f = new Zi())
f.方法名() ;报错了. 父类中没有子类特有功能!
class Father{
public void show(){
System.out.println("show father...");
}
}
//子类
class Son extends Father{
public void show(){
System.out.println("show son...");
}
//特有功能:
public void playGame(String gameName){
System.out.println("会玩"+gameName+"游戏");
}
}
//测试类
public class DuoTaiDemo3 {
public static void main(String[] args) {
//父类引用指向子类对象:向上转型
Father father = new Son() ;
father.show();
//father.playGame() ; //编译都报错了: 父类中没有玩游戏的功能 ,玩游戏属于Son类的特有功能
System.out.println("-------------------------");
}
}
方案1: (不推荐)
具体的子类创建具体的子类对象 Zi z = new Zi() ;
z.成员方法名() ;
本身Fu f = new Zi() ;已经在堆内存中开辟空间了
Zi z = new Zi() ;在堆内存中又开辟空间,从内存角度考虑,这种比较消耗内存空间,不太好!
方案2:(推荐使用:"向下转型")
多态的第三个前提条件:父类 引用指向子类对象 :"向上转型 "Fu f = new Zi() ;
能不能将父类的引用转换成子类的引用? 好处:不需要在堆内存开辟空间
可以------>"向下转型"
Zi z = (Zi)f ; 还原成子类型
强转类型转换: 目标类型 变量名 =(目标类型)初始化值;
//父类
class Father2{
public void show(){
System.out.println("show father...");
}
}
//子类
class Son2 extends Father2{
public void show(){
System.out.println("show son...");
}
//特有功能:
public void playGame(String gameName){
System.out.println("会玩"+gameName+"游戏");
}
}
//测试类
public class DuoTaiDemo4 {
public static void main(String[] args) {
//父类指向子类对象
Father2 father2 = new Son2() ;
father2.show(); //编译看左,运行看右,存在重写
//father2.playGame( "lol");//父类没有方法
System.out.println("------------------------------");
//方案1:创建具体的子类对象
Son2 son2 = new Son2() ;
son2.playGame("lol");
System.out.println("------------------------------");
/**
* "向下转型"
* Zi z = (Zi)f ; 还原成子类型
*/
Son2 s = (Son2) father2;
s.playGame("csgo");
}
要使用向下转型,前提必须有父类引用指向子类对象 Fu f = new Zi() ;
遵循向下转型的格式:
Zi z = (Zi)f; 必须心里清楚堆内存存储的类型....
向下转型使用不当,就出现java.lang.ClassCastException:类转换异常: (属于运行时期异常)
当前堆内存中的实例不是该类型时,就会出现问题!
//定义一个动物类
class Animal{
public void eat(){
System.out.println("动物都需要吃饭");
}
}
//狗类
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
//猫类
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
//测试类
public class DuoTaiDemo {
public static void main(String[] args) {
//多态版测试猫
Animal a = new Cat() ;//此时 堆内存是猫 (猫是动物)
Cat c = (Cat) a ; //还原成猫类型 :猫是猫
a = new Dog() ; //此时:堆内存是狗 (狗是动物)
Dog d = (Dog)a; //还原成狗的类型: 狗是狗
Cat cc = (Cat)a ;//现在没有报错:语法正确的:符合强转类型语法格式,运行出错java.lang.ClassCastException:类转换异常
}
}
什么是抽象类----->现实世界事物中,某个事物是比较概括性(人/水果/动物),描述为抽象事物
将一些公共性内容抽取到独立的类中,并且有些功能仅仅给出声明,不具体实现,具体实现通过子类进行,
只有具体的工人/苹果/猫或者狗,才具备具体的功能;
将某个事物中的一些功能仅仅给出声明即可,没有方法体----->抽象方法---->此时这个类必须为抽象类!
举例:
动物都需要吃和睡
只要看到具体的动物类:猫类/狗类,才具备吃和睡的功能
将动物类中的吃和睡给出一个声明:加入一个关键字 abstract:抽象方法
动物类----->抽象类*
抽象的关键字:Java语言 :abstract关键字 (抽象的含义)
抽象方法的格式;
权限修饰符(一般情况都是public) abstract 返回值类型 方法名(形式参数列表) ;
抽象类的格式:
abstract class 类名{}
1)有抽象方法的类一定是抽象类
2)抽象类中不一定只有抽象方法 ,还可以非抽象方法(有方法体)
3)抽象类不能实例化---->意思:不能创建对象
如何实例化呢:通过具体的子类进行实例化(进行对象的创建), 抽象类多态 Fu fu = new Zi() ;Fu类型 抽象类型
4)抽象类的子类有两种情况:
1)目前来说:如果抽象类的子类都是抽象类---毫无意义 因为子类也不能new ,除非再有具体的子类
2)抽象类的子类具体类---才能new :抽象多态的形式 Fu fu = new Zi() ;
抽象类的核心宗旨:就是强制子类必须完成的事情(要将父类中的所有的抽象方法必须重写,否则报错!)
抽象类成员特点:
成员变量
既可以定义变量,也可以常量:被final修饰
成员方法
既可以定义为抽象方法,也可以定义为非抽象方法
如果定义为抽象方法:关键字abstract(显示给出)
构造方法
存在无参构造/有参构造方法---->目的:分层初始化
//定义一个动物类
abstract class Animal{
/*public void eat(){
System.out.println("动物都需要吃饭");
}*/
public abstract void eat(); //加入关键字abstract
public void show(){//具体方法
System.out.println("show animal...");
}
public abstract void slepp() ;//睡
public Animal(){ //Animal抽象类=---- 不能new Animal()
System.out.println("Animal的无参构造方法");
}
}
//子类
//目前来说:如果抽象类的子类都是抽象类---毫无意义 因为子类也不能new ,除非再有具体的子类
//abstract class Cat extends Animal{
//具体类
class Cat extends Animal{
public Cat(){
System.out.println("Cat的无参构造方法");
}
@Override
public void eat() {
System.out.println("猫吃鱼...");
}
@Override
public void slepp() {
System.out.println("猫趴着睡觉...");
}
//特有功能
public void playGame(){
System.out.println("猫玩毛线");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void slepp() {
System.out.println("狗侧着睡觉...");
}
//特有功能
public void catchRabit(){
System.out.println("狗可以抓兔子");
}
}
//测试类
public class AbstractDemo {
public static void main(String[] args) {
//创建动物类对象
//类名 对象名 = new 类名() ;
// Animal a = new Animal() ;//不能创建对象,如何实例化呢?
//使用多态的形式: 当前的Animal类的子类一定是具体类
Animal a = new Cat() ;//父类引用指向子类对象(父类---抽象类) : 抽象类多态
a.eat();
a.slepp();
// a.playGame() ; 父类没有这个功能
//向下转型
Cat c = (Cat)a ;
c.playGame();
System.out.println("-------------------------");
a = new Dog() ;
a.eat();
a.slepp();
Dog d = (Dog) a;
d.catchRabit();
}
}
面试题:
一个类中没有抽象方法,那么将这个类定义为抽象类的意义何在?
意义:为了不让它直接实例化!
如何实例化:
情况1)直接就有具体的子类
情况2)间接的有具体的子类
可能:某个功能的返回值是它本身----->功能里面的逻辑可能就是在new 最具体的子类!
1)private冲突:
私有的方法,只能在本类中访问,加入abstract目的需要被子类重写,需要调用子类的功能!
2)static冲突:
静态方法随着类的加载而加载,而静态方法---算不上重写,所以它的访问
通过类名.方法名()---->而抽象方法没有方法体
3)final冲突
被final修饰的成员方法是不能被重写的,而加入abstract的方法需要被重写的!
abstract能够跟的关键字
public
默认修饰符
protected:受保护的 (范围:同一个包下的当前类或者子类中或者不包下的子类)
abstract一般在类上使用---->抽象类
在方法上使用---->抽象方法
可以在接口中使用
接口---->它的本质就是体现一个现实世界事物所具有的的额外的扩展功能!
定义格式: interface 接口名{} ------>接口名遵循"标识符规则"---->大驼峰命名法
接口中的方法:不能有方法体,隐藏public abstract关键字,只能是抽象方法,不能有方法体
1)不能实例化(不能创建对象)
2)如何实例化
接口实例化: 通过接口的子实现类(一定是具体类)进行实例化----接口多态(使用时最多的!)
子实现类和接口的关系: implements 实现关系
接口的子实现类如果是抽象类----->肯定要存在抽象类的具体的子类,否则都不能实例化!
开发中--->在接口名的后面+Impl:子实现类
interface Inter{}
class InterImpl implements Inter{
}
//定义一个接口:
interface Jump{ //跳高接口
public abstract void jump() ;
}
//定义一个跳高猫类
class JumpCat implements Jump{ //实现关系--->关键字:implements
@Override
public void jump() {
System.out.println("猫可以跳高了...");
}
}
//测试类
public class InterfaceDemo {
public static void main(String[] args) {
//创建接口对象
//Jump jump = new Jump() ;//不能实例化
//接口多态:----- 之前抽象类多态:Fu fu = new Zi() ; Fu类抽象类
//接口--->指向子类实现类对象
Jump jump = new JumpCat() ;
jump.jump(); //编译看左,运行看右!(接口只能有抽象方法)
}
}
1)接口中的成员方法: 只能是抽象方法,默认的修饰符:public abstract(可以省略不写)
2)接口没有构造方法
3)接口的成员变量只能是常量: 存在默认修饰符:public static final (可以省略不写)
1)成员的区别:
抽象类中
成员变量:既可以是常量,也可以是变量
成员方法:既可以是抽象方法(abstract不能省略),也可以是非抽象方法
构造方法:既存在无参构造方法,也可以存在有参构造方法(目的:为了给当前类进行数据初始化)
abstract class Animal{
private String name ;
private int age ;
private String color ;
public Animal(){}
pbblic Animal(String name,int age,String color){
this.name = name ;
this.age = age ;
this.color = color ;
}
public abstract void eat() ;
}
class Cat extends Animal{
public Cat(){
}
public Cat(String name,int age,String color){
super(name,age,color) ;
}
public void eat(){
//...
}
}
Animal a = new Cat() ; //抽象类多态
接口中
成员变量:只能是常量,存在默认的 修饰符 public static final (可以省略不写)
成员方法:只能是抽象方法:存在默认修饰符 public abstract(省略不写)
构造方法:没有构造方法,接口中所有的方法---都认为是没有方法体
2)关系的区别
三点
类与类之间的关系: extends 继承关系
只支持单继承,不支持多继承,但是可以多层继承
类和接口的关系: implements关系:实现关系
个类继承另一个类的同时,可以实现多个接口,中间逗号给隔开
接口与接口之间: extends:继承关系
不仅支持单继承,也可以多继承,中间使用逗号隔开
3)设计理念的区别
抽象类--->不能实例化---通过具体的子类实例化---->存在继承关系,体现的是一种 "is a"的关系
接口---->不能实例化--->通过具体的子实现类实例化---->谁如果实现了接口,就具备额外的功能,体现的是一种"like a"的关系
instanceof:提供操作符号(二元(二目)操作符号:) 最终true/false
==
>=
<=
>
<
对象 instanceof 引用类型
描述左边的对象是否是当前右边的类型的实例 (实例---->对象)
abstract class Animal{
public Animal() {
}
public abstract void eat() ;
}
class Dog extends Animal{
public Dog() {
}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
class Pig extends Animal{
@Override
public void eat() {
System.out.println("猪吃白菜...");
}
}
//测试类
public class Test3 {
public static void main(String[] args) {
Animal a = new Dog() ;
a = new Pig() ;
//if语句
if(a instanceof Dog){
System.out.println("是狗类型的实例");
}else if(a instanceof Cat){
System.out.println("是猫类型的实例");
}else if(a instanceof Pig){
System.out.println("是猪类型的实例");
}else{
System.out.println("对不起,没有当前实例...");
}
}
}
形式参数问题的研究:引用类型
如果方法的形式参数是类 调用方法的时候,如何传递实际参数?
具体类 :调用该方法,实际参数需要传递当前具体类的对象
抽象类 :调用该方法实际参数需要传递的抽象类的子类对象 (抽象类多态)
接口 : 调用该方式,实际参数需要传递的是当前接口的子实现类对象(接口多态)
//定义一个接口
interface Love{
void love() ;
}
//LoveDemo类
class LoveDemo { //Love love = new LovePerson() p
public void function(Love l){//方法的形式参数是接口类型,必须传递接口的子实现类对象
l.love();//love.love() ;
}
}
//定义一个接口的子实现类
class LovePerson implements Love{
@Override
public void love() {
System.out.println("爱生活,爱Java,爱高圆圆...");
}
}
//测试类
public class LoveTest {
public static void main(String[] args) {
//需要访问LoveDemo类中的function方法
//创建LoveDemo类对象
LoveDemo ld = new LoveDemo() ;
//Love love = new Love() ; //接口不能实例化
//接口多态
Love love = new LovePerson() ;
ld.function(love) ;
System.out.println("------------------------");
//匿名对象
new LoveDemo().function(new LovePerson());
}
}
如果一个方法的返回值是引用类型,最终方法结束,如何返回?
具体类 :方法返回的就是当前具体类对象!
抽象类 :需要返回的是抽象类的子类对象
接口:需要返回的是该接口的子实现类对象
1)具体类
class Student{
public void study(){
System.out.println("Good Good Study,Day Day Up!");
}
}
//StudentDemo类
class StudentDemo {
public Student show() { //方法的返回值是引用类型---具体类 :需要返回的当前类的具体对象
return new Student();
}
}
//测试类
public class StudentTest {
public static void main(String[] args) {
//调用StudentDemo类中的show方法?
//创建StudentDemo类对象
StudentDemo sd = new StudentDemo() ;
Student s = sd.show(); //Student s = new Student(); sd.show()---->返回的具体的学生对象
s.study();
System.out.println("-----------------------");
//匿名对象
Student student = new StudentDemo().show();
student.study();
}
}
2)抽象方法
abstract class Person{
public abstract void work() ;
}
//定义一个子类 继承Person类
class Worker extends Person{
@Override
public void work() {
System.out.println("工人不断的去工作...");
}
}
//PersonDemo类
class PersonDemo{
public Person method(){ //返回值类型是一个引用类型---抽象类的情况,需要返回的是抽象类的子类对象
// Person p = new Worker() ;
//return p ;
//一步走
//匿名对象
return new Worker() ;
}
}
//测试类
public class PersonTest {
public static void main(String[] args) {
//需要调用PersonDemo类中的method 方法?
PersonDemo pd = new PersonDemo() ;
Person person = pd.method(); // method方法其完成了一件事件: Person person = new Worker() ;
person.work() ;
System.out.println("---------------------------------");
//匿名对象
Person p = new PersonDemo().method();
p.work() ;
}
}
3)接口
//定义一个接口
//结婚的接口
interface Mary{
public abstract void mary() ;
}
//定义一个类
class You implements Mary{
@Override
public void mary() {
System.out.println("结婚了,很开心...");
}
}
//MaryDemo类
class MaryDemo{
public Mary function(){//返回值类型是接口类型,
//需要提供接口的子实现类对象
//接口多态
// Mary mary = new You() ;
// return mary ;
//一步走
return new You() ;
}
}
//测试类
public class LoveTest {
public static void main(String[] args) {
//调用MaryDemo类中的function方法?
MaryDemo maryDemo = new MaryDemo() ;
Mary mary = maryDemo.function();
mary.mary();
System.out.println("----------------------");
//匿名对象
Mary m = new MaryDemo().function();
m.mary();
}
}
包:关键字 package
包的真实含义:
以后要代码分层...
将包进行划分
开发中,写包名的时候(字母都是小写,多级包) :公司域名反写
开发中:
先按照模块划分,在按照功能划分
用户模块
注册功能
登录功能
用户激活功能(使用邮件激活技术,手机短信验证,微信二维码)
用户退出
商品模块
订单模块
购物车模块
支付模块
举例:
com.qf.pojo/entity/domain : 存储实体类
com
qf
pojo
存储实体类----能够描述现实世界事物
User类 用户
name,password,birthday,sex,email 属性:姓名,密码,出生日期,性别,邮箱
商品实体 商品
Product 属性:商品名称,商城价格,市场价格上架日期,
pname,shop_price,market_price,pdesc,pdate,....
开发中:
com.qf.dao : 数据库访问层
com
qf
dao
UserDao: 用户数据库持久层 (针对用户数据库访问接口层---->JDBC(Java连接数据库))
两个功能:注册/登录功能
public abstract boolean isLogin(User user) ;
public abstract boolean register(User user) ;
com.qf.dao.impl(针对用户数据库访问接口实现层)
UserDaoImpl implements UserDao
重写isLogin(User user)和register(User user)功能
业务层代码:
com.qf.service :
UserService:针对用户的业务接口层
登录/注册的业务
com.qf.service.impl:针对用户的业务接口实现层
UserServiceImpl implements UserService
注册:
判断用户名和密码在数据库中是存在,如果存在,
就不能在注册了;如果不存在,可以进行注册
登录:
首先通过用户名先找到用户User----如果找到User
继续判断 User里面的密码是否和前台输入的密码是否一致,
如果一致,登录成功,
否则,错误信息提示....
控制层: 控制业务层数据--->进行页面的渲染(视图):jsp,freemarker:网页静态化.... (模板引擎)
com.qf.controller:
UserController :
调用UserService层:获取业务层数据
通过后期:请求转发/重定向技术---进行页面跳转 (后期:开源框架:springmvc:视图解析器)
同一个包下的当前类中 | 同一个包下的子类/无关类中 | 不同包下的子类中 | 不同包下的无关类中 | |
---|---|---|---|---|
private | √ | |||
默认 | √ | √ | ||
protected | √ | √ | √ | |
public | √ | √ | √ | √ |
修饰的权限从小到:private,默认,protected,public
内部类:
在一个类中可以定义另一个:
在类A 中定义了类B,将类B就称为类A的内部类,类A就是外部类!
成员内部类:
在一个类的成员位置中定义了另一个类
内部类可以访问外部类的成员,包括私有!
//外部类
class Outer{
//成员变量
public int num = 100 ;
private int num2 = 200 ;
class Inner{ //成员内部类
//成员内部类的一个成员方法
public void method(){
System.out.println("method Inner");
System.out.println();
System.out.println(num2);
}
}
//外部类的成员方法
public void show(){
//访问的成员内部类的method--->通过创建内部类对象来访问
//method() ;错误的----访问的本类的method方法
Inner inner = new Inner() ;
inner.method();
}
}
//测试
public class InnerClassDemo {
public static void main(String[] args) {
//创建外部类对象
Outer outer = new Outer() ;
outer.show();
}
}
1)外部类如何直接访问内部类的成员方法?
格式:
外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象() ;
class Outer2{
private int num = 20 ;
//成员内部类
class Inner2{
public void show(){
System.out.println(num);
}
}
//外部类的成员方法
public void method(){
// 创建内部类对象访问内部类的成员方法
}
}
//测试类
public class InnerClassDemo2 {
public static void main(String[] args) {
//外部类名.内部类名 对象名 = 外部类对象.内部类对象;
//适用于:通过外部类直接访问成员内部类的成员(前提条件:当前成员内部类是一个非静态类)
Outer2.Inner2 oi = new Outer2().new Inner2() ;
oi.show() ;
}
}
2)关于我们成员内部类的修饰符:
在成员内部类上面---加入private修饰:为了数据的安全性,它的访问---就要外部类的公共访问间接访问...
伪代码
举例:
人首先身体---身体内有心脏
class Body{
//内部类:心脏
private class Heart{ //加入private:保证数据的安全性
//手术
public void operator(){
System.out.println("心脏搭桥手术....") ;
}
}
//外部类提供一些公共访问
public void method(){
if("如果你是外科医生"){
Heart heart = new Heart() ;
heart.operator() ;
}
}
}
//外部类直接访问成员内部类的成员
3)如果当前成员内部类是静态的, 里面的方法无论是静态的还是非静态的,都只能访问外部类的静态成员,包括私有!
如何直接访问静态成员内部类的成员呢?
将静态的成员内部类看成是外部类的静态成员访问
直接访问方式
外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
class Outer3{
//定义非静态的成员变量
public int num = 50 ;
private static int num2 = 20 ;
//定义成员内部类:静态的 ---->静态的成员内部类可以看成是外部类的静态成员
static class Inner3{//此时类都是静态
public void show(){
// System.out.println(num);
System.out.println(num2);
}
public static void show2(){
// System.out.println(num);
System.out.println(num2);
}
}
}
//测试类
public class InnerClassDemo3 {
public static void main(String[] args) {
// 外部类名.内部类名 对象名 = 外部类对象.内部类对象;
//Outer3.Inner3 oi = new Outer3().new Inner3() ; 适用不了了
// 外部类名.内部类名 对象名 = new 外部类名.内部类名() ;
Outer3.Inner3 oi = new Outer3.Inner3() ;
oi.show();
oi.show2() ; //静态---不推荐对象名访问
System.out.println("------------------------------");
//show2()的另一种方式
Outer3.Inner3.show2(); //show2()静态方法
}
}