从0开始学JAVA （小记）

学习网址

头歌平台：点这里，自动跳转
public static void main(String[] args){}这个是程序的主入口，在你学习java基础阶段，你的代码都需要写在这里就行啦

Java关键字是区分大小写的哦！所以void是关键字，但Void就不是了，public是关键字Public就不是了~~
标识符就是：在程序中自定义的一些名称

标识符的组成：标识符由 26个英文字母大小写，数字：0-9符号：_$组成
在JAVA中有三种注释：1.文档注释，2.单行注释，3.多行注释

单行注释：在要要添加注释的代码或文字之前添加 //,即可。
多行注释：在需要添加注释的代码或文字之前添加 /**,之后添加 /即可。
文档注释：在需要添加注释的代码或文字之前添加/ ,之后添加 */**即可。


Java基本类型共有八种，基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。

Scanner

而Scanner就是用于用户在Java程序中输入数据的。
所以对于Scanner你可以理解为，它就是一个扫描仪，用来获取我们从键盘输入的数据。

怎么使用？
你只需要记住三个步骤：

在类的声明之前，引入扫描仪（Scanner）：import java.util.Scanner;
在方法中创建一个扫描仪 Scanner input = new Scanner(System.in);
通过扫描仪获取从键盘输入的数据 int i = input.nextInt();
double i = input.nextDouble();

string数组的定义不太一样

//在这里给stuNames数组赋值  分别为   张三,张无忌,张三丰,张岁山
		stuNames = new String[]{"张三","张无忌","张三丰","张岁山"};

new 这个关键字来确定数组的大小或初始数据我们称之为动态初始化。

"== "比较的是两个对象的内存地址，我们知道变量被创建的时候就相当于在内存中开辟空间，而案例中str和str1就是占用的两块不同的空间，所以他们的内存地址是不一致的，在用==符号判断的时候就不相等了，即为false。
String str = "hello"和String str1 = "hello"没有进行对象的创建，而是同时指向的一个对象，所以他们的内存地址是相同的。


在Java中判断两个字符串是否相等，需要使用equals方法；

使用Arrays.toString(数组)可以直接输出数组中的值哦！

类

人是一个 “类”，小明就是人的 “对象”

class Student{  
//声明这个是一个学生类  
}  

什么是类
类：类是一个模板，它描述一类对象的行为和属性。
对象：对象是类的一个实例，有 属性 和 行为 。
类—>对象—>属性

综上我们可以发现创建对象使用的公式就是：
类名 对象名 = new 类名();
给对象的属性赋值：
对象名.属性名 = 值;
使用对象的属性：
对象名.属性名
调用对象的方法：
对象名.方法名();

什么是构造方法

构造方法：对象被创建的时候会调用的方法，对象在被创建的时候，也就是被new的时候，会自动调用构造方法。

好，我来总结一下，看你是否能在上图中找出相对应的代码：

构造方法可以有参数，也可以无参数；

构造方法无返回值，也不需要声明void关键字；

构造方法名必须和类名相同。

class是类，public/void是方法，int/String等是属性

使用this关键字，设置对象的成员变量。

什么是成员变量
成员变量就是对象的属性：



this()调用的是Person自己的无参构造方法，this.name访问的是Person对象自身的name，而方法参数中的name则表示方法传入的值。

package step3;
import java.util.Scanner;
public class Test {  
    public static void main(String[] args) {  
        Scanner sc = new Scanner(System.in);  
        String name = sc.next();  
        int age = sc.nextInt();  
        String sex = sc.next();  
        Person p = new Person(name,age,sex);  
        p.display();  
    }  
}
class Person{  
    String name = "张三";  
    int age = 18;   
    String sex = "男";  
    /********** Begin **********/
    public Person(String name,int age,String sex){  
        this(age);  
        this.name = name;  
        this.sex = sex;  
    }  
    public Person(int age){  
        this.age = age;  
    }  
    public void display(){  
        String name = "李四";  
        int age = 11;  
        String sex = "男";  
        System.out.println("name：" + this.name);  
        System.out.println("age：" + this.age);  
        System.out.println("sex：" + this.sex);  
    }

包，

包就像我们windows系统中的文件夹一样，只不过包是专门存放代码文件的。

包的主要作用就是给代码文件分类。

static关键词设置方法和变量的属性。

static*变量

注意：如果一个类的成员变量被static修饰了，那么所有该类的对象都共享这个变量。无论这个类实例化多少对象，它的静态变量只有一份拷贝。

static*方法

用static关键字修饰的方法叫做静态方法。静态方法我们已经用过，它有一个特点相信你已经很熟悉，那就是不需要创建对象就可以直接使用。
如：

注意：

static*代码块

现静态代码块是不需要依赖main方法就可以独立运行的。

关于静态代码块你只需要记住一句话：在类被加载的时候运行且只运行一次。

静态代码块中变量和方法的调用也遵守我们之前所说的规则，即只能直接调用静态的属性和方法

练习题：

解答：

①是静态代码块，可以直接执行
②静态方法，不需要先创建对象
③是静态方法，只能引用静态变量

【方法总结】

普通方法 ：void int 任意名(）{}
构造方法 void int 类名(）{}
静态方法 static void int c(）{}

封装的意义

对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处：

良好的封装能够减少耦合。
类内部的结构可以自由修改。
可以对成员进行更精确的控制。
隐藏信息，实现细节。
封装把一个对象的属性私有化，同时提供一些可以被外界访问属性的方法，如果不想被外界访问，我们大可不必提供方法给外界访问。但是如果一个类没有提供给外界访问的方法，那么这个类也没有什么意义了。

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，

package case1;

public class TestPersonDemo {
	public static void main(String[] args) {
		/********* begin *********/
		// 声明并实例化一Person对象p
		Person p =new Person();
		// 给p中的属性赋值
		/**
		name和age为p的私有属性，因此无法直接使用：p.age;
		必须对象对外开放的接口如：setName方法
		*/
		p.setName("张三");
		p.setAge(18);
		// 调用Person类中的talk()方法
		p.talk();
		/********* end *********/

	}
}

// 在这里定义Person类
class Person {
	/********* begin *********/
	private String name ;//私有属性 name，age
	private int age;

/*setter()、getter()是该对象对外开放的接口*/
//包含无参有返回值 与 有参无返回 两种情况。
	public	String setName(){
		return name;
	}
	public void setName(String name){
		this.name = name;
	}

	public int  setAge(){
		return age;
	}
	public void setAge(int age){
		this.age = age;
	}

	void talk(){
		System.out.println("我是："+name+"，今年："+age+"岁");
	}

	/********* end *********/
}

Java类的继承

class 父类 // 定义父类  
{  
    ...  
}  
class 子类 extends 父类 // 用extends关键字实现类的继承  
{  
    ...  
}  

继承的特性

子类拥有父类非private的属性和方法；

子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；

子类可以用自己的方式实现父类的方法；

在Java中只允许单继承，而不允许多重继承，也就是说一个子类只能有一个父类，但是Java中却允许多层继承，多层继承就是，例如类C继承类B，类B继承类A，所以按照关系就是类A是类B的父类，类B是类C的父类，这是Java继承区别于C++继承的一个特性；

提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

所以由此可以得出结论，子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再调用本类中的相应构造方法。

super显示调用父类的有参构造方法

class Student extends Person{  
    String school ;  
    // 子类的构造方法  
    public Student(){  
        super() ; //实际上在程序的这里隐含了这样一条语句  
        System.out.println("2.public Student(){}");  
    }  

package case2;

public class extendsTest {
	public static void main(String args[]) {
		// 实例化一个Cat对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
		Cat c = new Cat();
		c.getName("大花猫");
		c.getAge(6);
		c.voice();
		c.eat();
		System.out.println(c.getName()+c.getAge()+"岁");
		/********* end *********/

		// 实例化一个Dog对象，设置属性name和age，调用voice()和eat()方法，再打印出名字和年龄信息
		/********* begin *********/
		Dog g = new Dog();
		g.getName("大黑狗");
		g.getAge(8);
		g.voice();
		g.eat();
		System.out.println(g.getName()+g.getAge()+"岁");
		/********* end *********/

	}
}

class Animal {
	/********* begin *********/
	private String name;
	private int age;

	public String getName(){
		return name;

	}
	public void getName(String name){
		this.name= name;

	}
	public int getAge(){
		return age;

	}

	public void getAge(int age){
		this.age= age;

	}
	/********* end *********/

}

class Cat extends Animal {
	// 定义Cat类的voice()和eat()方法
	/********* begin *********/
	
	void voice(){
		System.out.println("大花猫喵喵叫");

	}
	void eat(){
		System.out.println("大花猫吃鱼");

	}
	/********* end *********/
}

class Dog extends Animal {
	// 定义Dog类的voice()和eat()方法
	/********* begin *********/
	void voice(){
		System.out.println("大黑狗汪汪叫");

	}
	void eat(){
		System.out.println("大黑狗吃骨头");
		
	}

	/********* end *********/
}

注意：
System.out.println(g.getName()+g.getAge()+“岁”);
g.getName()一定要加 （）

super

super关键字出现在子类中，主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。

super关键字的用法如下：  

super可以用来引用直接父类的实例变量。
super可以用来调用直接父类方法。
super()可以用于调用直接父类构造函数。

super都是在方法中调用的

注意：如果没有使用super()或this()，则super()在每个类构造函数中由编译器自动添加。

super与this关键字的比较
super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。
this关键字：指向自己的引用。

package case3;

public class superTest {
	public static void main(String[] args) {
		// 实例化一个Student类的对象s，为Student对象s中的school赋值，打印输出信息
		/********* begin *********/
		Student s = new Student("张三",18,"哈佛大学");

		System.out.println("姓名："+s.name+"，年龄："+s.age+"，学校："+s.school);

		/********* end *********/
	}
}

class Person {
	/********* begin *********/
	String name;
	int age;

	Person(String name1, int age1){
		this.name = name1;
		this.age = age1;

	}
	/********* end *********/
}

class Student extends Person {
	/********* begin *********/
	String school;
	Student(String name1, int age1,String school1){
		super(name1,age1);
		this.school=school1;
	}
		
	
	/********* end *********/
}

方法的重写（override）

方法的重写

== 子类从父类中继承方法，有时，子类需要修改父类中定义的方法的实现，==这称做方法的重写(method overriding)。“重写”的概念与“重载”相似，它们均是Java“多态”的技术之一，所谓“重载”，即是方法名称相同，但却可在不同的场合做不同的事。当一个子类继承一父类，而子类中的方法与父类中的方法的名称、参数个数和类型都完全一致时，就称子类中的这个方法重写了父类中的方法。“重写”又称为“复写”、“覆盖”。
方法的重载（overload）

方法的重载

首先回顾一下前面所讲的方法的重载，方法重载是指多个方法可以享有相同的名字，但是参数的数量或类型不能完全相同。
调用方法时，编译器根据参数的个数和类型来决定当前所使用的方法。方法重载为程序的编写带来方便，是OOP多态性的具体变现。在Java系统的类库中，对许多重要的方法进行重载，为用户使用这些方法提供了方便。

package case4;
 
public class overridingTest {
	public static void main(String[] args) {
		// 实例化子类对象s，调用talk()方法打印信息
		/********* begin *********/
		String name="张三";
		int age=18;
		String school="哈佛大学";
		Student s = new Student(name,age,school);
		s.talk();
		/********* end *********/
		
	}
}
 
class Person {
	/********* begin *********/
	String name;
	int age;
	String school;
	public void talk(){
 
	}
	/********* end *********/
}
 
class Student extends Person {
	/********* begin *********/
	Student(String name,int age,String school){
		this.name = name;
		this.age = age;
		this.school = school;
	}
		public void talk(){
		super.talk();
		System.out.println("我是："+name+"，今年："+age+"岁，我在"+school+"上学");
	}
	/********* end *********/
}

抽象类

Java也可以创建一种类专门用来当作父类，这种类称为“抽象类”。抽象类的作用有点类似“模版”，其目的是要设计者依据它的格式来修改并创建新的类。但是并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由它来创建对象。
如何定义抽象类
抽象类的定义规则：

抽象类和抽象方法都必须用abstract关键字来修饰；

抽象类不能被实例化，也就是不能用new关键字去产生对象；

抽象方法只需声明，而不需实现；

含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

package case5;

public class abstractTest {
    public static void main(String[] args) {
        /********* begin *********/
        // 分别实例化Student类与Worker类的对象，并调用各自构造方法初始化类属性。
        Student s = new Student("张三",20,"学生");
        Worker w = new Worker("李四",30,"工人");
        s.talk();
        w.talk();

        // 分别调用各自类中被复写的talk()方法 打印信息。

        /********* end *********/

    }
}

// 声明一个名为Person的抽象类，在Person中声明了三个属性name age occupation和一个抽象方法——talk()。
abstract class Person {
    /********* begin *********/
    String name;
    int age;
    String occupation;
    public abstract void talk();
    /********* end *********/
}

// Student类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class  Student extends Person {
    /********* begin *********/
    Student(String name,int age,String occupation){
        this.name = name;
        this.age = age;
        this.occupation = occupation;
    }
    public void talk(){
        System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }
    /********* end *********/
}

// Worker类继承自Person类，添加带三个参数的构造方法，复写talk()方法 返回姓名、年龄和职业信息
class Worker extends Person {
    /********* begin *********/
    Worker(String name,int age,String occupation){
        this.name = name;
        this.age = age;
        this.occupation = occupation;
    }
   
    public void talk(){
        System.out.println("工人——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
    }

    /********* end *********/

}

final关键字的使用

在Java中声明类、属性和方法时，可使用关键字final来修饰。

final标记的类不能被继承；

final标记的方法不能被子类复写；

final标记的变量（成员变量或局部变量）即为常量，只能赋值一次。

通常 static与final一起 使用来指定一个类常量。

接口

接口（interface）是Java所提供的另一种重要技术，它的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有以下两点不同：

接口里的数据成员必须初始化，且数据成员均为常量；

接口里的方法必须全部声明为abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。
注意在抽象方法里，没有定义方法主体

接口与一般类一样，本身也具有数据成员与方法，但数据成员一定要赋初值，且此值将不能再更改，方法也必须是“抽象方法”。也正因为方法必须是抽象方法，而没有一般的方法，所以抽象方法声明的关键字abstract是可以省略的。

在Java中接口是用于实现多继承的一种机制

package case7;

public class interfaceTest {
	public static void main(String[] args) {
		// 实例化一Student的对象s，并调用talk()方法，打印信息
		/********* begin *********/
		Student s = new Student();
		s.talk();
		/********* end *********/

	}
}

// 声明一个Person接口，并在里面声明三个常量：name、age和occupation，并分别赋值，声明一抽象方法talk()
interface Person {
	/********* begin *********/
	final String name= "张三";
	final int age = 18;
	final String occupation="学生";
	 
	 abstract void talk();

	/********* end *********/
}

// Student类继承自Person类 复写talk()方法返回姓名、年龄和职业信息
class Student implements Person {
	/********* begin *********/
	
	public void talk(){
		System.out.println("学生——>姓名："+name+"，年龄："+age+"，职业："+occupation+"！");
	}
	/********* end *********/
}

什么是多态

所谓多态：就是指一个类实例的相同方法在不同情形有不同表现形式。多态机制使具有不同内部结构的对象可以共享相同的外部接口

package case8;

public class TestPolymorphism {
	public static void main(String[] args) {
		// 以多态方式分别实例化子类对象并调用eat()方法
		/********* begin *********/
		Animal dog = new Dog();
		dog.eat();
		Animal cat = new Cat();
		cat.eat();
		Animal lion = new Lion();
		lion.eat();
		/********* end *********/
	}
}

// Animal类中定义eat()方法
class Animal {
	/********* begin *********/
	public void eat(){

	}
	/********* end *********/
}

// Dog类继承Animal类 复写eat()方法
class Dog extends Animal {
	/********* begin *********/
	public void eat(){
		System.out.println("eating bread...");
	}
	/********* end *********/
}

// Cat类继承Animal类 复写eat()方法
class Cat extends Animal {
	/********* begin *********/
	public void eat(){
		System.out.println("eating rat...");
	}
	/********* end *********/
}

// Lion类继承Animal类 复写eat()方法
class Lion extends Animal {
	/********* begin *********/
	public void eat(){
		System.out.println("eating meat...");
	}
	/********* end *********/
}

package case1;
 
import java.util.Scanner;
 
public class Task1 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		String dogName = sc.next();
		String dogSex = sc.next();
		String dogColor = sc.next();
		String catName = sc.next();
		String catSex = sc.next();
		double catWeight = sc.nextDouble();
		// 通过有参构造函数实例化Dog类对象dog
		// dog调用talk()方法
		// dog调用eat()方法
		/********* begin *********/
		Dog dog = new Dog(dogName,dogSex,dogColor);
        dog.talk();
        dog.eat();
 
 
		
		/********* end *********/
		// 通过有参构造函数实例化Cat类对象cat
		// cat调用talk()方法
		// cat调用eat()方法
		/********* begin *********/
		Cat cat = new Cat(catName, catSex, catWeight);
        cat.talk();
        cat.eat();
		
		/********* end *********/
	}
}
 
// 抽象类Pet 封装属性name和sex
// 构造函数初始化name和sex
// 声明抽象方法talk()
// 声明抽象方法eat()
abstract class Pet {
	/********* begin *********/
	   private String name;
    private String sex;
 
    public String getName() {
        return name;
    }
 
    public String getSex() {
        return sex;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setSex(String sex) {
        this.sex = sex;
    }
 
    public Pet(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
 
    abstract void talk();
 
    abstract void eat();
 
 
	/********* end *********/
}
 
// Dog类继承自Pet类 封装属性color
// 构造函数初始化name、sex和color
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，颜色：color，汪汪叫'
// eat()输出'name吃骨头'
class Dog extends Pet {
	/********* begin *********/
 	private String color;
 
    public String getColor() {
        return color;
    }
 
    public void setColor(String color) {
        this.color = color;
    }
 
    public Dog(String name, String sex, String color) {
        super(name, sex);
        name = super.getName();
        sex = super.getSex();
        this.color = color;
 
    }
 
    
    public void talk() {
 
        System.out.println("名称：" +super.getName()+"，性别："+getSex()+"，颜色："+color+"，汪汪叫");
    }
 
   
    public void eat() {
        System.out.println(super.getName()+"吃骨头！");
    }
	
	/********* end *********/
}
 
// Cat类继承自Pet类 封装属性weight
// 构造函数初始化name、sex和weight
// 实现自己的talk()方法和eat()方法
// talk()输出'名称：name，性别：sex，体重：weight kg，喵喵叫'
// eat()输出'name吃鱼'
class Cat extends Pet {
	/********* begin *********/
	private double weight;
    public Cat(String name, String sex, double weight){
        super(name, sex);
        name=super.getName();
        sex=super.getSex();
        this.weight=weight;
    }
 
   
    void talk() {
        System.out.println("名称："+getName()+"，性别："+getSex()+"，体重："+weight+"kg，"+"喵喵叫");
 
    }
 
   
    void eat() {
        System.out.println(getName()+"吃鱼！");
    }
 
 
 
	/********* end *********/
}

错误：

多态演示

public class TestAnimalDemo {  
    public static void main(String[] args) {  
        show(new Cat()); // 以 Cat 对象调用 show 方法  
        show(new Dog()); // 以 Dog 对象调用 show 方法
        Animal a = new Cat(); // 向上转型  
        a.eat(); // 调用的是 Cat 的 eat  
        Cat c = (Cat) a; // 向下转型  
        c.work(); // 调用的是 Cat 的 work  
    }
    public static void show(Animal a) {  
        a.eat();  
        // 类型判断  
        if (a instanceof Cat) { // 猫做的事情  
            Cat c = (Cat) a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情  
            Dog c = (Dog) a;  
            c.work();  
        }  
    }  
}
abstract class Animal {  
    abstract void eat();  
}
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }
    public void work() {  
        System.out.println("看家");  
    }  
}  

error: non-static variable this cannot be referenced from a static context=

上下文环境中找不到静态变量name,age

故得出的结论是：
静态方法里只能使用静态变量；
同样的：
类方法里，只能使用类变量。

方法总结

package test;
/*知识点目录
1，Java继承
1.1 继承的概念
1.2 继承的特性
1.3 继承关键字
1.4 构造器
2，Java重写（Override）与重载（Overload）
2.1 重写（Override）
2.2 重载（Overload）
2.3 总结
3，Java多态
3.1 多态的实现方式
4，Java抽象类
5，Java封装
6，Java接口
*/

/* 1.1继承的概念

继承在本职上是特殊——一般的关系，即常说的is-a关系。子类继承父类，表明子类是一种特殊的父类，并且具有父类所不具有的一些属性或方法。通过 extends 关键字可以声明一个类是从另外一个类继承而来的。
*/

/* 1.2继承的特性

1).子类拥有父类非private的属性，方法；
2).子类可以拥有自己的属性和方法，即子类可以对父类进行扩展；
3).子类可以用自己的方式实现父类的方法；
4).Java的继承是单继承，这是Java继承区别于C++继承的一个特性；
5).提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
*/

/* 1.3继承关键字

1).使用 extends 和 implements 来实现继承，所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承Object；
2).一个子类只能拥有一个父类，所以 extends 只能继承一个类；
3).使用 implements 关键字变相的使Java具有多继承的特性，为类继承接口，可以同时继承多个接口；
4).通过super关键字来实现对父类成员的访问，用来引用当前对象的父类；
5).final 关键字
5.1) 声明类则把类定义为不能继承的，即最终类；修饰方法，则该方法不能被子类重写；定义实例变量，则变量不能被修改；
5.2) final 类的方法自动为 final方法，但实例变量不自动是 final变量。
*/

interface A{}  
interface B{}
class Animal{  
   public void move(){  
       System.out.println("动物可以移动");  
   }  
   Animal(){  
       System.out.println("Animal()");  
   }  
   Animal(int n){  
       System.out.println("Animal(int)");  
   }  
}
final class Dog extends Animal implements A,B {
   final String name = "旺财";  
   final public void finalFun(){
   }
   /* 2.1.1 重写（Override）  
    1).重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写；  
    2).重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法；  
    3).重写方法不能抛出新的检查异常或者比被重写方法声明更加宽泛的异常。  
    */  
   public void move(){  
       System.out.println("狗可以跳墙");  
   }
   /*2.2.1重载(Overload)  
   1).重载是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同；  
   2).每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。  
    */  
   public void move(int n){  
       System.out.println("这只狗可以跳"+n+"米的墙");  
   }
   public String toString() {  
       //1.3.1 通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。  
       return "I am a Dog " + super.toString();  
   }
/* 1.4 构造器  
1).子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表；  
2).如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。  
*/  
   Dog(){  
       super(300);  
       System.out.println("Dog()");  
   }  
   Dog(int n){  
       System.out.println("Dog(int)");  
   }  
}
class Test{  
   static void testsuper(){  
       System.out.println("-----testsuper----");  
       new Dog();  
       new Dog(1);  
   }  
   static void testoverride(){  
       System.out.println("-----testoverride-----");  
       Animal a = new Animal();  
       Animal b = new Dog();  
       a.move();
       /*2.1.2  重写（Override）  
       1).尽管b属于Animal类型，但是它运行的是Dog类的move方法；  
       2).在编译阶段，只是检查参数的引用类型。在运行时，Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。  
        */  
       b.move();  
   }  
}
public class JavaDemo{  
   public static void main(String[] args) {
       Test.testsuper();  
       Test.testoverride();  
   }  
}

/* 2.1.3方法的重写规则

1).参数列表必须完全与被重写方法的相同；
2).返回类型必须完全与被重写方法的返回类型相同；
3).访问权限不能比父类中被重写的方法的访问权限更低；
4).父类的成员方法只能被它的子类重写；
5).声明为final的方法不能被重写；
6).声明为static的方法不能被重写，但是能够被再次声明；
7).子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法；
8).子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法；
9).重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常，但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以；
10).构造方法不能被重写；
11).如果不能继承一个方法，则不能重写这个方法。

2.2.2重载规则

1).被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
2).被重载的方法可以改变返回类型；
3).被重载的方法可以改变访问修饰符；
4).被重载的方法可以声明新的或更广的检查异常；
5).方法能够在同一个类中或者在一个子类中被重载；
6).无法以返回值类型作为重载函数的区分标准。
/
/
重写与重载之间的区别
区别点 重载方法 重写方法
参数列表 必须修改 一定不能修改
返回类型 可以修改 一定不能修改
异常 可以修改 可以减少或删除，一定不能抛出新的或者更广的异常
访问 可以修改 一定不能做更严格的限制（可以降低限制）
总结
方法的重写和重载是Java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载是一类中多态性的一种表现。
*/
/*访问控制修饰符
Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
默认的，也称为 default，在同一包内可见，不使用任何修饰符；
私有的，以 private 修饰符指定，在同一类内可见；
共有的，以 public 修饰符指定，对所有类可见；
受保护的，以 protected 修饰符指定，对同一包内的类和所有子类可见。
我们可以可以通过以下表来说明访问权限：
访问控制
修饰符 当前类 同一包内 子孙类 其他包
public Y Y Y Y
protected Y Y Y N
default Y Y N N
private Y N N N
*/

/*3，Java多态

多态就是同一个接口，使用不同的实例执行不同操作。
3.1 多态的实现方式 重写、接口、抽象类和抽象方法。
*/

/*4，Java抽象类

1).使用abstract class来定义抽象类，抽象类不能被实例化；
2).抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类；
3).抽象类中的抽象方法只是声明，不包含方法体；
4).构造方法，类方法（用static修饰的方法）不能声明为抽象方法；
5).任何子类必须重写父类的抽象方法，或者声明自身为抽象类。
*/
abstract class Employee{
//抽象方法
public abstract double computePay();
}
/*4.2继承抽象类
/
class Salary extends Employee{
public double computePay(){
return 0;
}
}
/

5，Java封装

封装（英语：Encapsulation）是指，一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装的优点：
1).良好的封装能够减少耦合；
2).类内部的结构可以自由修改；
3). 可以对成员变量进行更精确的控制；
4). 隐藏信息，实现细节。
实现Java封装的步骤：
1). 修改属性的可见性来限制对属性的访问；
2).对每个值属性提供对外的公共方法访问。
/
/

6，Java接口

1).接口，在Java编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明；
2).一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类；
3).接口不能包含成员变量，除了 static 和 final 变量；
4).接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract；
5).接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量；
6).接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法；
7).类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常；
8).类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型；
9).接口的继承使用extends关键字,允许多重继承,可能定义或继承相同的方法。
*/
interface C extends A,B{}

7、 equals与==

判断两个基础数据类型是否相等，使用的是双等号,判断的是内存地址是否一致。
判断字符串是否相等需要使用equals方法,比大小。

8、StringBuffer

stringBuffer.append(“World!”);
stringBuffer.reverse()

String string1 = "Hello World!";  
StringBuffer stringBuffer = new StringBuffer(string1);  //String转换为StringBuffer  
String string2 = stringBuffer.toString();  //StringBuffer转换为String  

基本数据类型就不能调用方法

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

//输入int型值aa传递给Integer类对象a
		Integer a = new Integer(aa);
		Integer b = new Integer(bb);

		System.out.println(a == b);
		System.out.println(a == c);
		System.out.println(b == c);
		System.out.println(a.equals(b));
		
//输入String型值str11传递给String类对象str1；
		String str1 = new String(str11);
		String str2 = new String(str22);

		System.out.println(str1 == str2);
		System.out.println(str1.equals(str2));
		

int x1=str.indexOf(“.”)+1;
int x2=str.indexOf(“.”,x1);
//x2的意思为从指定索引处开始，返回第一次出现的指定字符串中的索引
//通俗意思是先从指定处x1开始查找，直到查到该指定字符串，然后返回该字符串的索引

// 分别以1、2、3作为种子数 生成6位随机密码
		Scanner sc = new Scanner(System.in);
		int seed = sc.nextInt();
		/********* Begin *********/
		Random r = new Random(seed);

		int[] arr = r.ints(6, 0, 62).toArray();//生成六个0~62范围的整数
		for(int i=0; i<6; i++){
			//char[i]=pardStore[arr[i]];
			System.out.print(pardStore[arr[i]]);
		}

Java中获取当前日期和时间很简单，使用Date对象的toString()方法来打印当前日期和时间，

package educoder;
import java.util.Date;
public class DateDemo {  
    public static void main(String args[]) {  
        // 初始化 Date 对象  
        Date date = new Date();
        // 使用 toString() 函数显示日期时间  
        System.out.println(date.toString());  
    }  
}  

java比较日期

Java使用以下三种方法来比较两个日期：

使用getTime()方法获取两个日期自1970年1月1日经历的毫秒数值，然后比较这两个值；

使用方法before()，after()和equals()。例如，一个月的12号比18号早，则 new Date(99, 2, 12).before(new Date (99, 2, 18))返回true；

使用compareTo()方法，它是由Comparable接口定义的，Date 类实现了这个接口。

SimpleDateFormat

Math类

Math.toDegrees

这个方法是将-π/2到π/2之间的弧度值转化为度，例如：Math.toDegrees(Math.PI/2)结果为90.0；

Math.toRadians

这个方法是将度转化为-π/2到π/2之间的弧度值，例如：Math.toRadians(30)结果为π/6；

Math.sin、Math.cos、Math.tan这三个方法是三角函数中的正弦、余弦和正切，反之Math.asin、Math.acos、Math.atan是他们的反函数。

指数函数方法；

**Math.exp(a)**方法主要是获得以 e 为底 a 为指数的数值；
*Math.log()*和Math.log10()是对数函数；
*Math.pow(a,b)*是以a为底b为指数的值；
Math.sqrt() 是开根号。

取整方法；

Math类里包含五个取整方法：Math.ceil()方法是往大里取值；Math.floor()方法是往小里取值；Math.rint()方法返回与参数最接近的整数，返回类型为double，注意.5的时候会取偶数；Math.round()方法分两种：int型和long型，Math.round(a)就是Math.floor(a+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。

min、max和abs方法

取最大值和最小值以及绝对值。

random方法。

生成随机数取值范围是0.0到1.0的double型数值。也可以用简单的表达式生成任意范围的随机数，例如：
(int）(Math.random()*10) 返回0到9之间的一个随机整数。

Java中的异常

1、检查性异常；

2、运行时异常；

常见的运行时异常：

ClassCastException(类转换异常)  
IndexOutOfBoundsException(数组越界)  
NullPointerException(空指针)  
ArrayStoreException(数据存储异常，操作数组时类型不一致)  

3、错误。

有一部分异常是需要程序员提前处理的，这种异常统一称为检测性异常如果我们不处理，程序是不能编译通过的，在IDE中也会出现一条红线。

try-catch

Java中提供了一个捕获异常的机制：try-catch
所以我们在捕获异常的时候最好要先明确异常的种类是什么。

ArithmeticException属于运行时异常，是在运行时检测的，所以上述代码编译是能通过的，而FileNotFoundException是属于检测性异常，是在编译之前就需要处理的，所以第二段程序要加上throws才能通过编译。

//检测性异常可以用try-catch来处理，那运行时异常可不可以用try-catch来处理呢？
try{
			System.out.println(num1/num2);
		}catch(RuntimeException e){
			System.out.println("除数不能为0");
		}

throw和throws关键字。

throw关键字

throw

throw关键字的作用是：主动抛出异常；

throw是语句抛出一个异常，一般是在代码块的内部，当程序出现某种逻辑错误时由程序员主动抛出某种特定类型的异常。

注意：使用throw关键字主动抛出检测性异常的时候，在方法名上必须使用throws表明调用这个方法可能存在要抛出的异常。

使用自定义异常

我们一般使用继承Exception类的方式来自定义异常，

package step4;

import java.util.Scanner;

public class Task {
	/********* Begin *********/
	public static void main(String[] args) throws MyException{
		Scanner sc = new Scanner(System.in);
		String username = sc.next();

		//判断用户名
		if (username.length()<3){
			throw new MyException("用户名小于三位Exception");
		}
		System.out.println("用户名格式正确");		
	}
}

class MyException extends Exception{
	public MyException(){

	}
	public MyException(String msg){
		super(msg);
	}
} 

/********* End *********/

创建文件

创建文件

package step1;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Scanner;

public class Task {
	/********* Begin *********/
	public void solution()            {
		try{
			File file1 = new File("src/output/test.txt");
			file1.createNewFile();
		}catch(IOException e){
			e.printStackTrace();
		}
		try{
			File file2 = new File("src/output/hello.txt");
			file2.createNewFile();
		}catch(IOException e){
			e.printStackTrace();
		}
	/********* End *********/
	}
}

创建文件夹

package step2;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.util.Arrays;


public class Task {
	public static void dcFile() throws IOException {
		/********* Begin *********/
//在src/下创建文件夹test2文件夹；
		File file = new File("src/test2");
		file.mkdir();

//删除src/output/下的test2.txt文件；
		File file1 = new File("src/output/test2.txt");
		file1.delete();
		
//在src/test2/目录下创建helloworld.txt文件和step2.txt文件；
		File file2 = new File("src/test2/helloworld.txt");
		file2.createNewFile();
		File file3 = new File("src/test2/step2.txt");
		file3.createNewFile();
		

//将src/output/目录和src/test2/目录下所有文件的文件名按升序排序并打印至控制台。
		File dir = new File("src/output");
		File[] files = dir.listFiles();
		Arrays.sort(files);
		System.out.println("output目录结构为：");
		for(File file11 : files){
			System.out.println(file11.getName());	
		}
		
		File dir1 = new File("src/test2");
		File[] file1s = dir1.listFiles();
		Arrays.sort(file1s);
		System.out.println("test2目录结构为：");
		for(File file22 : file1s){
			System.out.println(file22.getName());
		}
		/********* End *********/
	}
}

可以使用isDirectory()方法来判断一个File对象是否是一个文件夹。
java中的File类有listFiles方法可以获取文件目录。

文件过滤器，将过滤扩展名为.SYS的文件。

FileFilter filter = file ->  {  
    if (file.isFile()) {  
        String fileName   = file.getName().toLowerCase();  
        if (fileName.endsWith(".sys"))  {  
            return false;  
        }  
    }  
    return true;  
};