Java学习笔记

Java学习笔记

  • 1.知识点
  • 1.0Hello World
    • 1.1Java的枚举
    • 1.2类的构造函数,初始化对象
    • 1.3访问实例变量,调用成员方法
    • 1.4一个源文件只能有一个public类,且与源文件名称保持一致;可以有多个非public类,package语句放在首行,然后是import语句,类定义。
    • 1.5变量:局部,成员,静态,参数
    • 1.6继承
    • 1.7类自己的方法重载,子类继承父类后方法重写
    • 1.8多态:继承+重写+父类引用指向子类对象(向上转型)
    • 1.9一个类只能继承一个抽象类,可以实现多个接口
    • 1.10封装:一般限制为private,提供对外的公共方法访问
    • 1.11接口:interface声明,接口中的方法都是公有的,类使用implements关键字实现接口,接口可以多继承
    • 1.12枚举:enum关键字定义枚举类,方法:values(),ordinal(),valueOf()
    • 1.13包:java.lang打包基础的类,java.io包含输入输出功能的函数
    • 1.14ArryList类是可以动态修改的数组,没有大小限制,方法:add(),get(),set(),remove(),size()

1.知识点

1.0Hello World

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("hello world" );
    }
}

1.1Java的枚举

class FreshJuice{
    enum FreshJuiceSize{SMALL,MEDIUM,LARGE};
    FreshJuiceSize size;
}
public class FreshJuiceTest{
    public static void main(String[] args){
        FreshJuice juice= new FreshJuice();
        juice.size =FreshJuice.FreshJuiceSize.MEDIUM;
    }
}

1.2类的构造函数,初始化对象

public class Puppy {
    //2.1首先定义类的构造函数
    public Puppy(String name){
        System.out.println("我的小狗的名字是:"+name);
    }
    //2.2主函数创建对象,并用构造函数初始化对象
    public static void main(String[] args) {
        Puppy myPuppy=new Puppy("欢欢");
    }
}

1.3访问实例变量,调用成员方法

public class Cat {
    int catAge;//实例变量
    public Cat(String name){//构造方法
        System.out.println("我的小猫的名字是:"+name);
    }
    public void setAge (int age){//成员方法
        catAge=age;
    }
    public int getAge(){
        System.out.println("我的小猫的年龄是:"+catAge);//成员方法调用实例变量
        return catAge;
    }
    public static void main(String[] args) {
        Cat mycat=new Cat("费力罗");//使用构造方法初始化了一个对象
        mycat.setAge(3);//使用成员方法,设定实例变量
        mycat.getAge();
        System.out.println("年龄:"+mycat.catAge);//访问成员变量
    }
}

1.4一个源文件只能有一个public类,且与源文件名称保持一致;可以有多个非public类,package语句放在首行,然后是import语句,类定义。

Employee.java

public class Employee {
    String name;
    int age;
    String designation;
    Double salary;
    public Employee(String name){
        this.name =name;
    }
    public void  empAge(int empAge){
        age=empAge;
    }
    public void empDesignation(String empDesignation){
        designation=empDesignation;
    }
    public void empSalary(double empSalary){
        salary =empSalary;
    }
    public void printEmployee(){
        System.out.println("名字:"+name);
        System.out.println("年龄:"+age);
        System.out.println("职位:"+designation);
        System.out.println("薪水:"+salary);
    }
}

EmployeeTest.java,程序都是从main方法开始执行

import java.io.*;//载入java_installation/java/io路径下的所有类
public class EmployeeTest {
    public static void main(String[] args) {
        Employee empOne= new Employee("张三");
        Employee empTwo= new Employee("李四");
        empOne.empAge(26);
        empOne.empDesignation("高级工程师");
        empOne.empSalary(10000);
        empOne.printEmployee();
        empTwo.empAge(62);
        empTwo.empDesignation("初级工程师");
        empTwo.empSalary(100);
        empTwo.printEmployee();
    }
}

final关键字修饰常量;前缀0表示8进制,0x表示16进制

1.5变量:局部,成员,静态,参数

参数变量的两种传递方式:值传递和引用传递

public class RunoobTest {
    private int instanceVar;//成员变量
    private static int staticVar;//静态变量
    public void method(int paramVar){//参数变量
        int localVar=10;//局部变量
        instanceVar=localVar;
        staticVar=paramVar;
        System.out.println("成员变量:"+instanceVar);
        System.out.println("静态变量:"+staticVar);
        System.out.println("参数变量:"+paramVar);
        System.out.println("局部变量:"+localVar);
    }
    public static void main(String[] args) {
        RunoobTest v=new RunoobTest();
        v.method(20);
    }
}

1.6继承

6.1Extends继承一个父类,implements继承多个接口

public class Animal {
    private  String name;
    private int id;
    public Animal(String myname,int myid){
        name=myname;
        id=myid;
    }
    public void eat(){
        System.out.println(name+"正在吃");
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction(){
        System.out.println(name+"大家好!我是"+id+"号"+name+"。");
    }
}
public class Penguin extends Animal{
    public Penguin(String myname,int myid){
        super(myname,myid);
    }
}
public class Mouse extends Animal{
    public Mouse(String myname,int myid){
        super(myname,myid);
    }
}

6.2super关键字实现对父类成员的访问;this关键字指向自己的引用

class Creature {
    void eat(){
        System.out.println("creature:eat");
    }
}
class Dog extends Creature{
    void eat(){
        System.out.println("dog:eat");
    }
    void eatTest(){
        this.eat();//this调用自己的方法
        super.eat();//调用父类的方法
    }
}
public class Test{
    public static void main(String[] args) {
        Creature a=new Creature();
        a.eat();//父类对象用方法
        Dog d=new Dog();
        d.eatTest();//子类对象用两种方法
    }
}

1.7类自己的方法重载,子类继承父类后方法重写

1.8多态:继承+重写+父类引用指向子类对象(向上转型)

abstract class Animal2{
    abstract void eat();
}
class Cat2 extends Animal2{
    public void eat(){
        System.out.println("吃鱼");
    }
    public void work(){
        System.out.println("抓老鼠");
    }
}
class Dog2 extends Animal2{
    public void eat(){
        System.out.println("吃骨头");
    }
    public void work(){
        System.out.println("看家");
    }
}
public class Test2 {
    public static void show(Animal2 a){
        a.eat();
        if (a instanceof  Cat2){
            Cat2 c=(Cat2)a;
            c.work();
        }else if (a instanceof  Dog2){
            Dog2 c=(Dog2)a;
            c.work();
        }
    }
    public static void main(String[] args) {
        show(new Cat2());//Cat对象调用show方法
        show(new Dog2());
        Animal2 a=new Cat2();//向上转型
        a.eat();
        Cat2 c=(Cat2)a;//向下转型
        c.work();
    }
}

1.9一个类只能继承一个抽象类,可以实现多个接口

1.10封装:一般限制为private,提供对外的公共方法访问

/* EncapTest.Java*/
public class EncapTest {
    private String name;
    public void setName(String newName){
        name=newName;
    }
    public String getName(){
        return name;
    }
    private String idNum;
    public void setIdNum(String newId){
        idNum=newId;
    }
    public String getIdNum(){
        return idNum;
    }
    private int age;
    public void setAge(int newAge){
        age=newAge;
    }
    public int getAge(){
        return age;
    }
}
/*RunEncap.java*/
public class RunEncap {
    public static void main(String[] args) {
        EncapTest encap=new EncapTest();
        encap.setName("zoe");
        encap.setAge(28);
        encap.setIdNum("757");
        System.out.println("Name:"+encap.getName()+"age:"+encap.getAge() );
    }
}

1.11接口:interface声明,接口中的方法都是公有的,类使用implements关键字实现接口,接口可以多继承

1.12枚举:enum关键字定义枚举类,方法:values(),ordinal(),valueOf()

enum Color{
    RED,GREEN,BLUE;
    private Color(){//构造函数
        System.out.println(this.toString()+"构造时会遍历");
    }
    public void colorInfo(){
        System.out.println("color");
    }
}
public class Test3
{
    public static void main(String[] args) {
        Color c=Color.RED;
        System.out.println(c);
        c.colorInfo();
    }
}

1.13包:java.lang打包基础的类,java.io包含输入输出功能的函数

1.14ArryList类是可以动态修改的数组,没有大小限制,方法:add(),get(),set(),remove(),size()

你可能感兴趣的:(java,学习,笔记)