面向对象-修饰符 属性 数据类型 名称 ( 形参 )

修饰符 

public static void main (String[] args){}

修饰符 属性 数据类型 名称 ( 形参 )

什么是包、类、子类呢？

包就是文件夹，类就是文件，子类就是类里有继承关系，简单记就是类的名称后面加有extends

---

包：   IDEA快速导包快捷键ctrl + alt  + o   

可以多层

不同包下的文件名可以重复

包的声明必须是在最开头的代码

不同包之间互相访问 使用类的全名 使用关键字import将类导入  （称为导包）

包通常是小写单词，类名通常是大写单词

引用包： import 包的名称 . * ;

引用类: package 包名.类名;

相同包的类可以直接访问

*代表的是通配符，代表导入这个包下所有类，并没有导入子包下的类

为什么要导包呢，让程序找到另外的文件夹下的文件，读取文件

---

 

 权限修饰符：

        public 当前类，相同包下不同的类,不同包下的类使用，公共的

        default 当前类，相同包下不同的类使用

        private 当前类使用，私有的

        protected 当前类，相同包下不同的类  使用

        default:当前包下使用

        protected:让子类对象使用

default 缺省：系统默认 只能被同一个包的内部使用。也就是不写修饰符

protected：protected对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private（私有的）。

在同一个java文件中可以写多个的class，但只能有一个publice，其他的class只能缺省

作用域范围：public >  protected  >default  >private

---

属性：也就是java里的关键字

static

静态的。可以不用实例化对象就能用，直接通过 类名 . 属性名/方法名 的方式直接调用，类里的变量不能直接访问。方法中不能再定义方法，但可以调用方法。static 修饰符用来创建类方法和类变量。

---

final

全局的，用来修饰类、方法和变量，final 修饰的类不能够被继承但可以继承非final的方法，修饰的方法不能被重写，修饰的变量为常量，是不可修改的

final 与abstract不能共存

final 修饰符通常和 static 修饰符一起使用来创建类常量。

static final：全局常量 谁都可以用，而且有final属性的 只能赋值一次

成员变量必须在声明的同时或在每个构造方法中或代码块中显式赋值，然后才能使用。

声明 final 方法的主要目的是防止该方法的内容被修改。

class A {
    private final String INFO = "我是全局变量";//声明常量

    public void print() {
        //INFO = "使用";
        String name = INFO + "，这样才能被使用";
        System.out.println(name);
    }
}

这个final相对一个常量，只能被使用，不能赋值

---

abstract

用于修饰方法和类

抽象方法是一种没有任何实现的方法，该方法的具体实现由子类提供。

抽象方法：不同类的方法是相似的，但具体内容又不太一样，所以我们只能抽取它的声明，没有具体的方法体的方法

抽象方法只能在抽象类里面

抽象类和抽象方法必须要用abstract修饰

抽象类不能创建对象（不能实例化）

抽象类可以声明对象，但是不能实例化对象

抽象类可以有非抽象的方法

抽象类和类的关系也是继承

抽象类： 有抽象方法必须要有抽象类

一个类继承了抽象类，必须要重写它的所以的抽象方法，否则这个类就是抽象方法

抽象类可以有构造方法，需要对抽象类的成员变量进行初始化

不能用abstract修饰属性、私有方法、构造器、静态方法、final的方法。

abstract class A{  
       abstract void m1( );//只要其中一个方法是抽象方法的那么这个类就是抽象类
       public void m2( ){
      System.out.println("A类中定义的m2方法");
       }
}
class B extends A{
       void m1( ){  //把抽象方法重写  //一定得写的
       System.out.println("B类中定义的m1方法");
       }
}
public class Test{
       public static void main( String args[ ] ){
       A a = new B( );
       a.m1( );
       a.m2( );
       }
}

暂时不知道这个抽象类有啥用

---

数据类型

有基本的数据类型和包装类

数据类型对应的包

包装类开头字母是大写的哦

基本数据类型	包装类
boolean	Boolean
byte	Byte
short	Short
int	Integer
long	Long
char	Character
float	Float
double	Double

由于基本数据类型只能做一些简单的操作和运算，所以Java为我们封装了基本数据类型，为每种基本数据类型提供了包装类 ，包装类就是封装了基本数据类型的类，为我们提供了更多复杂的方法和一些变量。

什么时候用到包装类呢？

添加到集合中时，进行加减乘除和比较时

为什么用包装类呢？

通过各种方法的调用实现各种类型间的转换

操作：

基本数据类型包装成包装类的实例    ---装箱

通过包装类的构造器实现：

  int i = 500;   Integer t = new Integer(i);

还可以通过字符串参数构造包装类对象：

  Float f = new Float(“4.56”);   Long l = new Long(“asdf”);  //NumberFormatException

获得包装类对象中包装的基本类型变量    ---拆箱

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

//自动装箱
Integer i =20;//相当于Integer i=new Integer(20);
//自动拆箱
int a = i;//相当于int a = i.Value();

---

字符串转换成基本数据类型

通过包装类的构造器实现：

  int i = new Integer(“12”);

通过包装类的parse  xxx(String s)静态方法：

  Float f = Float.parseFloat(“12.1”);

基本数据类型转换成字符串,调用字符串重载的valueOf()方法：

  String fstr = String.valueOf(2.34f);

更直接的方式：String intStr = 5 +""

toString() 以字符串形式返回值。

装箱：包装类使得一个基本数据类型的数据变成了类。

有了类的特点，可以调用类中的方法。

int i = 500;
Integer t = new Integer(i);
String s = t.toString(); // s = “500“,t是类，有toString方法
String s1 = Integer.toString(314); // s1= “314“  将数字转换成字符串。
String s2="4.56";
double ds=Double.parseDouble(s2);   //将字符串转换成数字

---

面试题

public void print() {
        Integer i1 = 97;

        Integer i2 = 97;

        System.out.println(i1 == i2);

        System.out.println(i1.equals(i2));

        System.out.println("-----------");


        Integer i3 = 197;

        Integer i4 = 197;

        System.out.println(i3 == i4);

        System.out.println(i3.equals(i4));

    }

你觉得结果是什么？为什么呢？

 因为-128~127是byte的取值范围，如果在这个取值范围内，自动装箱就不会创建新的对象，而是从常量池中获取，超过了byte取值范围就会再创建新对象~这个就是 i1==i2 的结果为 true 的原因了

---

形参和实参

形参：方法传进去的值，只在传进去有效

形参与定义的方法参数类型一致 ，多个形参赋值可以有用逗号隔开

实参：成员变量

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。  即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响

实参和形参可以相同名字

但形参改变不了实参，实参可以改变形参的值