联合实验室 网站建设方案,网站 手机兼容,网站建设是怎么赚钱的,海口专注海南网站建设Java面向对象高级特性有以下几个#xff1a;继承#xff0c;多态#xff0c;封装#xff0c;抽象#xff0c;接口#xff0c;匿名内部类#xff0c;静态成员#xff0c;final关键字#xff0c;异常处理等。
我会将它分为三章详细讲#xff0c;本章主要讲静态和继承 …Java面向对象高级特性有以下几个继承多态封装抽象接口匿名内部类静态成员final关键字异常处理等。
我会将它分为三章详细讲本章主要讲静态和继承
static
static叫静态可以修饰成员变量、成员方法。
类变量(静态成员变量)有static修饰属于类在计算机里只有一份会被类的全部对象共享。
实例变量对象变量:无static修饰属于每个对象的。
package itchinajie.d1_static_demo;public class Test {public static void main(String[] args) {//目标掌握有无static修饰成员变量的用法特点//1、类变量的用法//类名.类变量推荐Student.name 张三;//对象.类变量不推荐Student s1 new Student();s1.name 马冬梅;Student s2 new Student();s2.name 秋雅;System.out.println(s1.name);//秋雅System.out.println(Student.name);//秋雅//2、实例变量的用法属于每个对象的变量//对象.实例变量s1.age 23;s2.age 18;System.out.println(s1.age);System.out.println(s2.age);//System.out.println(Student.age);}
}package itchinajie.d1_static_demo;public class Student {//类变量静态修饰变量static String name;//实例变量对象变量int age;
}类变量的应用场景
在开发中如果某个数据只需要一份且希望能够被共享(访问、修改)则该数据可以定义成类变量来记住。
系统启动后要求用户类可以记住自己创建了多少个用户对象了。 package itchinajie.d1_static_demo;public class User {//类变量public static int number;public User(){//User.number ;//注意在同一个类中访问自己的类的类变量才可以省略类名不写number;}
}package itchinajie.d1_static_demo;public class Test2 {public static void main(String[] args) {//目标通过案例来解释类变量的应用场景User u1 new User();User u2 new User();User u3 new User();User u4 new User();System.out.println(User.number);}
}类变量只需要一份且需要时被共享访问或修改
实例变量是每个对象都要有一份数据各不同如name、sorce、age
static修饰成员方法
类方法static修饰成员方法
类方法是指属于类本身而不是类的实例的方法。在Java中类方法通常使用关键字static进行修饰可以直接通过类名来调用而不需要实例化该类的对象。类方法被称为静态方法因为它们在内存中只有一份副本而不是每个实例都有自己的副本。类方法通常用于执行与整个类相关的操作例如工具类中的常用方法或者程序的入口方法main。
实例方法无static修饰成员方法
实例方法是指属于类的实例对象而不是类本身的方法。在Java中实例方法不使用static关键字修饰必须通过类的实例来调用。每个类的实例都有自己的实例方法它们可以访问和操作实例的属性并且可以调用其他实例方法。实例方法通常用于描述对象的行为和操作并且会随着每个对象的创建而存在不同的副本。
package itchinajie.d2_static_method;public class Student {double score;//类方法public static void printHelloWorld(){System.out.println(Hello World);System.out.println(Hello World);}//实例方法对象方法public void printPass(){System.out.println(成绩 (score 60 ? 及格 : 不及格));}
}package itchinajie.d2_static_method;public class Test {public static void main(String[] args) {//目标掌握用static修饰方法的用法//1、类方法的用法//类名.类方法推荐Student.printHelloWorld();//对象.类方法不推荐Student s new Student();s.printHelloWorld();//2、实例方法的用法//对象.实例方法s.printPass();//Student.printPass();//报错}
}在这里不得不提一嘴main方法我们之前常用的main方法能直接执行其他方法到底为啥呢
main方法能直接执行是因为在Java虚拟机(JVM)中程序在运行时会自动查找并调用名为main的方法作为程序的入口点。当你运行一个Java程序时JVM会寻找包含main方法的类并执行该方法。因此main方法就成为了程序的入口用户可以通过调用这个方法来启动整个程序的执行。
main方法是Java程序的入口方法是程序执行的起点。在Java程序中main方法是一个特殊的静态方法格式为 java public static void main(String[] args)
类方法和实例方法的区别
Java中的类方法和实例方法是面向对象编程中的两种基本方法类型它们在方法和对象的关系、调用方式、访问权限等方面存在差异。
1. **定义和归属**
- **类方法**静态方法使用static关键字修饰的方法。类方法属于类本身而不是类的某个对象。即使没有创建类的对象类方法也可以直接通过类名调用。
- **实例方法**没有使用static关键字修饰的方法。实例方法属于类的对象只能通过类的对象来调用。
2. **调用方式**
- **类方法**可以直接通过类名调用也可以通过类的对象调用。
- **实例方法**必须通过类的对象来调用。
3. **访问权限**
- **类方法**由于类方法属于类本身因此它们可以访问类的静态成员变量和方法。
- **实例方法**可以访问类的实例成员变量和方法也可以访问类的静态成员变量和方法。
4. **对实例变量和类变量的访问**
- **类方法**由于类方法不属于任何对象它们不能直接访问实例变量。但可以访问类变量变量。
- **实例方法**可以访问类的实例变量和类变量。
5. **使用super和this关键字**
- **类方法**由于类方法不依赖于类的任何对象所以它们不能使用super和this关键字因为这些关键字分别用于引用父类和当前类的对象。
- **实例方法**可以使用super和this关键字。
6. **内存分配和多态性**
- **类方法**类的所有对象共享类方法的方法体因此类方法在程序运行期间只被加载一次并且其方法体不会因为创建多个对象而重复执行。
- **实例方法**每个对象都有自己的方法体副本因此实例方法可以独立于其他对象进行操作。 这些区别体现了Java在方法设计上的灵活性和面向对象编程的原则。在实际开发中应根据需要选择使用类方法还是实例方法。
static的注意事项 package itchinajie.d4_static_attention;public class Student {static String schoolName;//类变量double score;//实例变量//1、类方法中可以直接访问类的成员不可以直接访问实例成员public static void printHelloWorld(){//注意同一个类中访问类成员可以直接省略类名不写schoolName 黑马;printHelloWorld2();//printPass();//报错// System.out.println(score);//报错}//类方法public static void printHelloWorld2(){}//2、实例方法中既可以访问类成员也可以直接访问实例成员//实例方法//3、实例方法中可以出现this关键字类方法中不能出现public void printPass(){schoolName 黑马;printHelloWorld2();System.out.println(score);printPass();System.out.println(this);}//实例方法public void printPass2(){}
}1、类方法中可以直接访问类的成员不可以直接访问实例成员。
2、实例方法中既可以访问类成员也可以直接访问实例成员。
3、实例方法中可以出现this关键字类方法中不可以出现this关键字。
static的应用知识代码块(源码用的认识即可) package itchinajie.d5_block;public class Student {static int number 80;static String schoolName 黑马;//静态代码块static{System.out.println(静态代码块执行了~~);//schoolName 黑马;}int age 18;//实例代码块{System.out.println(实例代码块执行了~~);//age 18;System.out.println(有人创建了对象 this);}public Student(){System.out.println(无参数构造器执行了~~);}public Student(String name){System.out.println(有参数构造器执行了~~);}
}package itchinajie.d5_block;public class Test {public static void main(String[] args) {//目标认识两种代码块了解他们的特点和基本作用(认识就行)System.out.println(Student.number);System.out.println(Student.number);System.out.println(Student.number);System.out.println(Student.schoolName);//黑马System.out.println(-----------------------------------);Student s1 new Student();Student s2 new Student(张三);System.out.println(s1.age);System.out.println(s2.age);}
}static的应用知识单例设计模式
什么是设计模式
1、一个问题通常有种解法其中肯定有一种解法是最优的这个最优的解法被人总结出来了称之为设计模式。
2、设计模式有20多种对应20多种软件开发中会遇到的问题。
饿汉式单例设计模式
把类的构造器私有定义一个类变量存储类的一个对象提供一个类方法返回对象。
package itchinajie.d6_singleIstance;public class A {//2、定义一个类变量记住类的一个对象private static A a new A();//1、必须私有类的构造器private A(){System.out.println(牛逼);}//3、定义一个类方法返回类的对象public static A getObject(){return a;}}饿汉式单例设计模式的一个特点就是在获取类的对象时对象已经创建好了。
package itchinajie.d6_singleIstance;public class Test {public static void main(String[] args) {//目标掌握饿汉式单例设计模式的写法A a1 A.getObject();A a2 A.getObject();System.out.println(a1);System.out.println(a2);}
}饿汉式单例设计模式的一个特点就是在获取类的对象时对象已经创建好了。
他适合做任务管理器对象、获取运行时对象。在这些业务场景下使用单例模式可以避免浪费内存。
而懒汉式单利设计模式是拿对象时才开始创建对象。
懒汉式单利设计模式
package itchinajie.d6_singleIstance;public class B {//2、定义一个类变量用于存储这个类的一个对象private static B b;//1、把类的构造器私有private B(){}//3、定义一个类方法这个方法要保证第一次调用时才创建一个对象后面调用时都会用这同一个对象返回public static B getInstance(){if (b null) {System.out.println(第一次创建对象~);b new B();}return b;}
}package itchinajie.d6_singleIstance;public class Test2 {/*掌握懒汉式单例的写法*/public static void main(String[] args) {B b1 B.getInstance();//第一次创建对象B b2 B.getInstance();System.out.println(b1 b2);}
}继承
继承Java中提供了一个关键字extends,用这个关键字可以让一个类和另一个类建立起父子关系。 继承的特点子类能继承父类的非私有成员(成员变量、成员方法)
继承后对象的创建子类的对象是由子类、父类共同完成的。
class 子类 extends 父类 {}
继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类新的类能吸收已有类的数据属性和行为并能扩展新的能力。
子类又被称为派生类 父类又被称为超类Super Class。
关于继承的详细内容请转一下文章java继承实现原理快来get_extends inheritance-CSDN博客
继承相关注意事项
权限修饰符
就是是用来限制类中的成员(成员变量、成员方法、构造器、代码块。)能够被访问的范围。 package itchinajie.d9_modifer;public class Demo {public static void main(String[] args) {//目标掌握不同权限修饰符的作用Fu f new Fu();//f.privateMethod();f.method();f.protectedMethod();f.publicMethod();}
}package itchinajie.d9_modifer;public class Fu {//1、私有只能在本类中访问private void privateMethod(){System.out.println(private);}//2、缺省本类同一个包下的类void method(){System.out.println(缺省);}//3、protected本类同一个包下的类任意包下的子类protected void protectedMethod(){System.out.println(protected);}//4、public本类同一个包下的类任意包下的子类在任意包下的任意类public void publicMethod(){System.out.println(public);}public void test(){privateMethod();method();protectedMethod();publicMethod();}
}单继承、Object类
Java是单继承的Java中的类不支持多继承但是支持多层继承。
一图便知为何不支持多继承: object类是java所有类的祖宗类。我们写的任何一个类其实都是object的子类或子孙类。
我们先创建3个类最后让他们互相继承试验一下
package itchinajie.d11_extends_feature;public class Test {public static void main(String[] args) {//目标掌握继承的两个注意事项//1、Java是单继承的一个类只能继承一个父类Java中的类不支持多继承但支持多层继承//2、Object类是Java类中所有类的祖宗}class A{}//extends Object{}class B extends A{}//class C extends B , A{}//报错class D extends B{}
}方法重写
什么是方法重写
当子类觉得父类中的某个方法不好用或者无法满足自己的需求时子类可以重写一个方法名称、 参数列表一样的方法去覆盖父类的这个方法这就是方法重写。
注意重写后方法的访问Java会遵循就近原则。
直接上案例感受
package itchinajie.d12_extends_override;import java.util.ArrayList;public class Test {public static void main(String[] args) {//目标认识方法重写掌握方法重写的常见应用场景B b new B();b.print1();b.print2(2,3);System.out.println(--------------------);Student s new Student(播妞,19);System.out.println(s.toString());//重写方法后 可使用System.out.println(s);ArrayList list new ArrayList();list.add(Java);System.out.println(list);}
}package itchinajie.d12_extends_override;public class A {public void print1(){System.out.println(111);}public void print2(int a,int b){System.out.println(1111111);}
}package itchinajie.d12_extends_override;public class B extends A{//方法重写Override//安全可读性好public void print1(){System.out.println(666);}
//申明不变重新实现//方法重写Overridepublic void print2(int a,int b){System.out.println(6666666);}
}package itchinajie.d12_extends_override;public class Student {private String name;private int age;public Student() {}public Student(String name, int age) {this.name name;this.age age;}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;}Overridepublic String toString() {return Student{ name name \ , age age };}
}方法重写的其它注意事项 重写小技巧
1、使用Override注解他可以指定java编译器检查我们方法重写的格式是否正确代码可读性也会更好 2、子类重写父类方法时访问权限必须大于或者等于父类该方法的权限(publicprotected缺省)。 3、重写的方法返回值类型必须与被重写方法的返回值类型一样或者范围更小。 私有方法、静态方法不能被重写如果重写会报错的。
子类中访问其他成员的特点
1、在子类方法中访问其他成员(成员变量、成员方法)是依照就近原则的。
先子类局部范围找。 然后子类成员范围找。 然后父类成员范围找如果父类范围还没有找到则报错。
2、如果子父类中出现了重名的成员会优先使用子类的如果此时一定要在子类中使用父类的怎么办
可以通过super关键字指定访问父类的成员super.父类成员变量/父类成员方法
package itchinajie.d13_extends_visit;public class Test {public static void main(String[] args) {//目标掌握子类中访问其他成员的特点就近原则Z z new Z();z.showName();}
}package itchinajie.d13_extends_visit;public class F {String name 父类名字;public void print(){System.out.println(父类的print方法执行);}
}package itchinajie.d13_extends_visit;public class Z extends F{String name 子类名称;public void showName(){String name 局部名称;System.out.println(name);//局部名称System.out.println(this.name);//子类成员变量System.out.println(super.name);//父类成员变量}}子类构造器的特点
子类的全部构造器都会先调用父类的构造器再执行自己。
子类构造器为什么要调用父类的构造器有啥应用场景
子类构造器可以通过调用父类构造器把对象中包含父类这部分的数据先初始化赋值再回来把对象里包含子类这部分的数据也进行初始化赋值。
package itchinajie.d14_extends_constructor;public class Test2 {public static void main(String[] args) {//目标搞清楚子类构造器为什么要调用父类的构造器有啥应用场景Teacher t new Teacher(张三,36,Java);System.out.println(t.getName());System.out.println(t.getAge());System.out.println(t.getSkill());}
}
class Teacher extends People{private String skill;public Teacher(String name,int age,String skill){super(name,age);this.skill skill;}public String getSkill() {return skill;}public void setSkill(String skill) {this.skill skill;}
}class People{private String name;private int age;public People() {}public People(String name, int age) {this.name name;this.age age;}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;}
}补充this(…)调用兄弟构造器
任意类的构造器中是可以通过this(.....)去调用该类的其他构造器的。 this(.…)和super(.…)使用时的注意事项
this(…)、super((.…)都只能放在构造器的第一行因此有了this(.…)就不能写super(.…)了反之亦然。
(本章图片均来自于黑马程序员视频)
