包:为了更好地组织类,java提供了包机制,区别类名和命名的空间;
作用: 避免了类重名
按照不同功能进行分类管理
控制访问权限
命名规则: 全都是小写字母
项目类型:com edu org pov
公司名称:huawei
项目名称
功能模块:窗口
关键字import用于将外部包导入如:
// java.util.Date是包的全名 java.util包的路径
import java.util.Date;
public class Test {
public static void main(String[] args) {
//Date 是上面java.util.Date的简写
Date d = new Date();
}
}
//注:简称相同的包名不能在同一个类中同时调用
访问权限修饰符
用来修饰类，成员变量，成员方法，内部类，控制对其访问的权限。
public：公共权限，修饰类、属性、方法，内部类。可以被任意类访问
protected：受保护的权限，修饰属性、方法，内部类。可以被同包访问，如果不是同包，必须 通过该类的子类才能访问
default：同包权限，修饰类、属性、方法。只能被同包的类访问
private：私有权限，修饰属性、方法。只能在本类中访问
面向对象语言的特征面向对象语言的三大特征
封装
继承
多态
注意与java语言的特征区分。
面向对象特征–封装封装的概念：将类的某些信息隐藏在类的内部（用访问权限修饰符来实现），不允许外部程序直接访问，而是通过该类提供的某个特定的方法来实现对隐藏信息的访问和操作。
封装的好处：隐藏类的实现细节，只能通过规定的方法访问，便于加入控制语句，方便修改实现
public class Dog{
private String name;
public Dog(){
}
public Dog(String name){
}
public void setName(String name){//name 的set方法
this.name=name;
}
public String getName(){//name的get方法
return this.name;
}
}
//注:不是只有使用private才能做到封装
public class TestDOg{
public static void main(String [] args){
Dog dog = new Dog("二哈");//使用构造方法初始化
//dog.name = "小七"; //直接访问成员变量赋值
Dog dog1 = new Dog();
dog1.setName("小黑");//使用set方法赋值
System.out.println(dog1.getName());
}
}
一个单例模式
设计模式：解决某一类问题的解决方案（模式）。
一个简单的单例模式：让一个类在程序中只创建一次对象
public class Dog{
private static Dog dog;
//使用static修饰是因为不加static修饰时是需要用对象调用的而外部是不能创建对象的,
public static Dog getDog(){
new Dod();
if(dog==null){
dog = new Dog;
}
return dog;//第一次new过后以后用到的都是一样的
}
}
public class Test{
public static void main(String[] args){
Dog dog1 = Dog.getDog();
Dog dog2 = Dog.getDog();
System.out.println(dog1);
System.out.println(dog2);
//两个输出应当是一样的
}
}
面向对象特征–继承
继承：继承是从已有的类中派生出新的类，新的类能吸收已有类的属性和行为，
并能扩展新的能力。
java不支持一个类继承多个类,可以多个类继承一个类,也就是一个父类只有一个直接子类.
Object是所有类的父类.
继承的优点：实现代码块的重复利用，子类中可以扩展子类特有的属性和方法。
//定义了一个父类
public class Fu{
String name;
int age;
public void eat(){
System.out.println("父类eat");
}
}
//定义了一个子类
public class Zi extends Fu{
pubic void print(){
System.out.println("名字是"+this.name);
}
}
//测试类
public class Test{
Zi z1 = new Zi();//创建一个子类的对象
z1.name="张三";//为z1的name进行赋值
z1.eat();//调用子类继承来的eat方法
z1.print();//调用子类中的print方法
}
继承的构造方法
在创建子类对象后,调用构造方法时是从上向下调用的.即先初始化父类信息.
super关键字:
super是用于调用父类成员变量和方法的关键字.
super()必须在子类构造方法的第一行使用,并且只能用一次.(不写时是默认调用父类的无参构造)
//定义了一个父类
public class Fu{
String name;
int age;
public void eat(){
System.out.println("父类eat");
}
public Fu(){
System.out.println("父类的无参构造")
}
public Fu(int j){
System.out.println("父类的有参构造")
}
}
//定义了一个子类
public class Zi extends Fu{
pubic void print(){
super.eat();//表示调用父类的eat方法
System.out.println("名字是"+this.name);
}
public Zi(){
//super();//不写时默认存在调用父类的无参构造
super(20);//表示调用父类的有参构造
System.out.println("子类的无参构造")
}
}
方法重写
//定义了一个子类
public class Zi extends Fu{
pubic void print(){
System.out.println("名字是"+this.name);
}
//重写Fu类中的eat方法.
public void eat(){
System.out.println("子类eat");
}
}
//测试类
public class Test{
Zi z1 = new Zi();//创建一个子类的对象
z1.name="张三";//为z1的name进行赋值
z1.eat();//调用子类重写的eat方法
z1.print();//调用子类中的print方法
}
方法重写@override:
静态的方法不能被重写;
不能使用比父类权限小的修饰符,返回值要相同,名称要相同,参数列表要相同.
抽象类定义类时会定义一些方法(功能),而有时方法(功能)是不确定的,这时就可以使用抽象.
使用abstract修饰得并且没有方法体的方法叫做抽象方法，使用abstract修饰的类叫做抽象类。
//定义抽象类
[修饰符] abstract class类名{
//定义一个抽象方法
[修饰符] abstract 方法返回值类型 方法名([参数列表]);
}
包含抽象方法的类必须是抽象类，但是抽象类可以不包含任抽象方法。如果一个类继承了抽象类那么这个类重写抽象类中所有的抽象方法或者也将此类定义为抽象类。
抽象类不能被实例化，因为抽象类可能含有抽象方法，抽象方法是没有方法体的不可以被调用。如果想要调用抽象类里的抽象方法，可以创建一个子类，在子类中实现抽象类中的抽象方法。
//定义了一个抽象的父类
public abstract class Fu{
String name;
int age;
//定义一个eat抽象方法
public abstract void eat();
}
//定义了一个子类
public class Zi extends Fu{
pubic void print(){
System.out.println("名字是"+this.name);
}
//实现父类中的抽象方法.
public void eat(){
System.out.println("父类eat");
}
}
面向对象特征–多态
多态：同一种事物，在不同时刻表现不同的状态。
条件:
1.要有继承关系(类继承类, 类继承抽象类, 类实现接口)
2.要有方法重写
3.父类的引用指向子类对象（将子类的对象当做父类使用）
优点：
消除了类之间的耦合关系，提高了程序的扩展性和维护性。
缺点：
父类的引用指向子类对象，不能访问子类特有的方法。
public abstract class Animal {
String name = "xiao";
//定义了一个抽象方法
public abstract void shout();
//sleep方法
public void sleep(){
System.out.println("睡觉");
}
//定义eat方法
public void eat(){
System.out.println("吃饭");
}
}
public class Dog extends Animal {
String name = "da";
//实现shout方法
@Override
public void shout() {
System.out.println("汪汪---");
}
//重写了父类的sleep方法
public void sleep() {
System.out.println("狗睡觉");
}
//在狗类添加的play方法
public void play() {
System.out.println("玩狗");
}
}
public class Test {
public static void main(String[] args) {
Animal dog = new Dog();//父类的引用指向子类对象
dog.shout();//调用子类的shout方法
dog.eat();//调用父类eat方法
System.out.println(dog.name);//dog.name指向的是父类中的name
dog.sleep();//调用的是子类中重写的sleep方法
//dog.play();//这里是不能通过编译的,play方法是Dog类特有的,不能通过父类对象调用.
}
}
多态的转型
多态的转型:为了解决多态的缺点：父类的引用指向子类对象
不能访问子类特有的方法。在一些情况中又会用
到子类特有的方法，所以添加了多态的转型。
自动转型：向上转型，子类型会自动转向（上升为）父类类型。
强制转换：向下转型，父类类型强制转向子类类型。
子类类名 引用变量名 = (子类类名) new 父类名;
注：只能是有继承关系的才能向下转型。
eg:以上程序为例
自动转型:Animal dog = new Dog();
强制转型:Dog dog1 = (Dog)Animal;
instanceof关键字
判断引用类型变量所指向的是什么类型.
父类引用变量 intanceof 具体子类类型 判断父类引用实际表示的对象是不是制定类型。 如：animal intanceof Dog 就是判断animal所指向的是不是Dog类型。final关键字
final修饰类，属性，方法。
被final修饰的类不能被其他类继承；
被final修饰的方法不能被重写；
被final修饰后的属性是常量，创建时需要对其赋值，赋值后不能改变；
final修饰的常量有两种初始化的方法：直接赋值，构造方法赋值（利用有参构造方法初始化）；
两种区别：直接赋值所有对象的值都是一样的；
通过构造方法赋值时每调用一次都会有一个独有的值。
接口接口类似于抽象类（可以看做一个彻底的抽象类，但是它不是类）
接口和抽象类都是用于在顶层的指定和规范。
接口的意义：java中一个类只能有一个父类，所以用接口可以实现多继承的逻辑。
接口关注实现类有什么能力，而不关心实现细节（不写具体代码）;
jdk8之前接口只能定义常量和抽象的方法;
接口不能实例化对象,没有构造方法;
类可以通过implement实现接口,一个类可以实现多个接口;
接口可以通过extends继承接口,并且一个接口可以继承多个接口;
接口也表示抽象(只需要设计功能),也是需要其他类来实现(继承)的
public interface Jiekou{
int a = 7;//所用属性默认为：public static final
void fangFa1(){}//抽象方法默认是:public abstract
public static void fangFa2(){}//静态方法,可直接通过接口调用,jdk8之后添加的
public default void fangFa3(){}//默认方法,通过子类调用,jdk8之后添加的
}
//一个类可以实现多个接口
//一个类可以实现多个接口
//一个类只能直接继承一个类
//当一个类实现一个接口的时候,类要实现接口中所有的抽象方法,否则,类必须声明为抽象类
