大二下学期-Java课堂笔记

Java编程思想
2018-3-7
public class HelloWorld {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
      System.out.println("Hello World!");
      Student stu1=new Student();
              stu1.name="Tom";
              stu1.age=18;
              stu1.gender=true;
              stu1.printInfo(); 
              stu1.printGener();
              stu1.printAlphabet();
    }

}

public class Student {
    int age;
    String name;
    boolean gender;
    void printInfo(){
        System.out.println(age+"\n"+name+"\n"+gender);
    }
    void printGener()
      {
          if(gender=true) {
              System.out.println("女");
          }
          else {
              System.out.println("male");
          }
      }
    void printAlphabet()
    {
        for(char zm='a';zm<='z';zm++)
            System.out.print(zm+" ");
   
    }
}

public class liu {
    public static void main(String[] args) {
int a=3;
char b='5';
char c=(char)(a+b);
int d=c;
System.out.println(d);
}
}

2018-3-9
1.包package是用来组织CLASS的结构单位对应于文件夹。
2.src源文件
类型java source file.java
编译下是
类型.class是目标程序（等同于C中.obj）
JAVA边解释边执行
3.方法重载 名同参不同，本类的方法名相同，修饰符 返回值无关
重载分为 构造方法重载 成员方法重载

public class Person{
private int age；
publicPerson（）{}///构造方法重载
public void shout（int time）成员方法重载
{for。。。。
System。。。
}
}
4.package basic2;
矩形
public class Rectangle {
double a,b;
void printZhouchang()
{
    double zhouchang=2*(a+b);
    System.out.println(zhouchang);
}
void printmianji()
{
    double mianji=a*b;
    System.out.println(mianji);
}
}

5.package basic2;

public class Circle {
double radius;

void printPerimeter(){
    double perimeter=2*Math.PI*radius;
    System.out.println(perimeter);
}

void printArea() {
    double area=Math.PI*radius*radius;
    System.out.println(area);
}
}

package basic2;

public class TestCircle {
    public static void main(String[] args)
    {
        Circle c1=new Circle();
        c1.radius=1.0;
        c1.printPerimeter();
        c1.printArea();
    }
}

6.构造函数（创建空间） 
a函数名和类名相同，
b返回值没有返回值类型（不为空有返回值）
Circle c1=new Circle(1.0);把返回值赋值给C1；
d执行调用构造函数：使用new才执行
c不能用final /static修饰

public Apple（）{//无参
num=10；
price=8.34f；}
public static void main（String【】 args）{
Apple apple = new Apple（）；}

publicApple（int n，float price）{//有参
num=n；
price=f；}
public static void main（String【】 args）{
Apple apple = new Apple（10，8.34f）；}

没有定义时系统会给一个默认的不带参数的构造函数。
该默认构造函数的作用返回该空间的地址

7.重载的构造函数可以相互调用，使用this（）
pubilc Circle(){
this(5)}//radius=5;
8.全局变量和局部变量 变量名重叠时隐藏全局变量,局部优先。
若想使用全局变量 则this.r=r;
this可以代表当前对象，也可以调用本类的其他构造函数

random
import
如果使用本包以外的类，需要使用import引入

9.随机数

package basic2;

import java.util.Scanner;

public class GuessNumber {
    int randNumber,guessNumber;
    void generateRand() {
        randNumber=(int)(Math.random()*101);
    }
    void readGuessNumber() {
        Scanner s=new Scanner(System.in);
        System.out.print("Please input your guess number:");
        guessNumber =s.nextInt();
                //s.close();
    }
     boolean compare(){
        //比较正确返回true错误返回false并提示是大还是小。
        if(guessNumber==randNumber) return true;
        else if(guessNumber>randNumber) 
            System.out.println(" 大了");
        else if(guessNumber<randNumber)
            System.out.println(" 小了");
        return false;
        
    }
    void play()
    {
        generateRand();//系统生成一个随机数
        do {
            readGuessNumber();
        }
        while(!compare());
        //输入一个数
        //比较：如果对了，结束；如果错了，继续输入
        System.out.println("-----------end--------------");
    }
public static void main(String[] args)
{
    GuessNumber game=new GuessNumber();
    game.play();
}
}

default默认

package basic2;

public class TestRectangle {
    public static void main(String[] args)
    {
        Rectangle rect1=new Rectangle();
        rect1.a=4;
        rect1.b=5;
        rect1.printZhouchang();
        rect1.printmianji();
    }
}

3.14
static变量为静态变量或类变量，
a内存中只有一个副本（实例变量有多个副本）；同一种class公用一个。
b引用时用（格式）  类名.变量名
c在静态方法中不能访问非静态的变量或方法也不能出现this
source-Generate constuctor usiing fileds
dstatic不能修饰局部变量
package asc;

public class Gender {

    public static final Gender MALE = new Gender();
    //static Gender MALE;
    //static Gender FEMALE;
    public static final Gender FEMALE = new Gender();
    
}

package asc;

public class Person {
    private String name;
    private Gender gender;
    public Person(String name, Gender gender) {
        this.name = name;
        this.gender = gender;
    }

}

package asc;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
Person tom=new Person("Tom",Gender.MALE);
Person rose=new Person("Rose",Gender.FEMALE);
    }

}

non_static实例变量或成员变量

常量final 所有变量名大写
新单词首字母大写，每出现一个新单词用下划线表示
final类没有子类 final和static/public连用

public static toString()这个方法在一个类中被定义时，该类的对象变量不是地址串而是toString

package asc;

public class Gender {

    public static final Gender MALE = new Gender();
    //static Gender MALE;
    //static Gender FEMALE;
    public static final Gender FEMALE = new Gender();
    public String toString() {
        if(this ==Gender.MALE) {
            return "Male";
        }
        else
        {
            return "Female";
        }
    }
}

定义枚举值
1构造函数私有化
2为每个枚举值定义一个public static final的常量
3为每个枚举值显示的串定义一个public String toSting的方法

enum枚举
省去1,2步，只是用大写字母在最前面写出即可

java bin 一个类的属性都私有，为每个属性提供一个getter，和setter，有一个默认的无参构造函数

201--3-21

为什么需要继承？
 1.代码重用的一种手段；
 2.实现多态的一种手段；

继承注意：
a单继承
b继承父类的代码和数据，但它不能访问声明为private的超类成员
c子类中可以增加父类没有的变量和方法
d子类中可以重载父类中已有的方法包括构造方法 实例方法 成员方法
e子类中构造函数可以通过super方法将父类的变量初始化
fJava中根类为object 若一个类没有extends继承任何类，默认会隐式继承object 

扩展类继承基类（父类）使用extends

扩展类可以从基类中得到：
实例变量；
类变量；
实例方法；
类方法；

扩展类实例的构造过程：
 子类对象创建前，父类对象必须先创建。
 所以，子类对象创建前，要调用父类对象的构造方法。

super作用：调用父类的构造函数
Java程序中定义的所有类的父类均为object
继承关系中的构造方法调用链：
不显式调用——系统会默认插入一条不带参数的super
显式调用——构造方法中的第一条语句，是super(bara)

父子“属性”同名，父“属性”隐藏父类后引用
实例变量：
  super.data
  强制类型 转换成父类后引用
（（父）子类对象名）.data

类变量：
  super.data
（（父）子类对象名）.data
  父类名.data

父子“类方法”同名，父"类方法"隐藏
super.method;
((父)子类对象名).method；
父类名.method（）；

方法覆盖（重写）(override)：父子“实例方法”同名，子覆盖父“实例方法”（注：）
 除子类中，其他任何途径都不能引用。
 super.method;
方法覆盖是实现多态的语法基础

2018-3-23
1.abstract
用其修饰的方法称为 抽象方法，该方法没有方法体。
2.（有方法头：：public abstract void action（）；）
3.abstract修饰的类为抽象类，抽象类不可以实例化（不可用new创建对象），但可以有构造方法
4.抽象方法一定定义在抽象类中 ，抽象类中可以没有抽象方法。
抽象方法一定会被覆盖。
static，private（子类中不见），final（修饰的方法为终极方法，修饰的常量，）不会被覆盖（不能做抽象方法）

5.final修饰的类为终极类，不允许有子类（不被继承）

6.接口interface
使用interface不是class定义一个接口（不能用接口创建对象，接口没有构造函数）
接口中只允许有public static final（公有静态常量）和}public abstract void action（）的方法等效void action（）}

7.一个类可以实现接口implements一个接口或多个接口， 多个时用逗号分隔开
class A implements Role，RIO，Cat{}
接口也是一种数据类型
编译后也有.class文件（接口本身是类）
public class Cire implements Calculate
8.一个类不能继承多个类，但是一个类可以有多个接口
接口是实现多重继承的语法机制
接口可以继承并且多重继承

9.
一般（大case） 兼容 特殊（小case）
double 兼容 int
父 兼容 子
fruit 兼容 Apple
总可以执行 父类变量 等于 子类变量
Role aRole=（）
Role role=sRole
子类变量=（子类型）父类变量++++//强制类型转换
兄弟类（同一父类下的子类）之间不兼容，之间不能做类型转换

10.
instanceof左边是对象变量名，右边是类型名
对象变量名 instanceof 类型名
如果该变量指向的对象是该类型的 返回true，否则返回false

return o instanceof Duck;//如果o为真返回true否则false

构造函数没有返回类型，有返回值，返回的是变量的地址

byte，char，int，bool，float，double，short，long数据类型

11.优先使用关联(has a)（组合），而不是继承(is a) .........favor composition over inheritance

2018-3-28

1.共有 .. 父类方法
  私有 .. 父类属性

2.string 类创建：
String 变量名=new String（“”）；
String 变量名=“”；
String s1=“qqq”；
String s2=“qqq”；//s1 s2指向地址相同

String s1=“qqq”；
String s2=new String（“qqq”）
比较大小
（s1.equals(s2)）

int j=1234567
String sNumber = String.valueOf（j）//将int型转换成字符串型

3.声明一个数组      int[] iArray;//int 型默认初始化
  创建数组          iArray =new int[10];
  for 循环遍历数组  for(int i=0;i<iArray.length;i++)
            {
                System.out.println("iArray[i]");
                }
遍历数组法二（for-each）

for(int element:iArray)
{
System.out.println(element);
}

4.对象数组
Duck[] duckArray;//声明
duckArray = new Duck[10];
for(i=0;i<duckArray.lenth;i++)
{
duckArray[i]=new Mallard();}//初始化
for(Duck element:duckArray)
{
System.out.println(element);
}

内存中两个区
堆：大 不规则
栈：小 规则

///////////////////////////////////////
集合
ArrayList类 是一个长度可变的对象引用数组，类似动态数组
迭代器 iterator 
    next（）获得集合序列中的下一个元素
    hasNext（）检查序列中是否还有元素
    remove（）将的带起新返回的元素删除

while（iterator.hasNext()）//遍历
{
    Object element = iterator.next();
    System.out.println("iterator="+element);
}
2018-4-3
1.byte[] buffer = new byte[16];//生产一个含有16个数组元素的随机数数组

2.
char[] helloArray = { 'r', 'u', 'n', 'o', 'o', 'b'};
      String helloString = new String(helloArray); //替换 String helloString =“helloArray”
      System.out.println( helloString );

2018-4-4
1.布局GridLayout
BorderLayout（边框布局）
2.创建监听器
、、、、、、、、、、、、、、
package c07;

import java.awt.GridLayout;
import java.awt.Panel;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;//效果include import

public class MainPanel {
    private JPanel panel;
    private JLabel jlInput,jlMessage;
    private JTextField jtfInput;
    private JButton jbOk,jbRestart;//创建组件之后布局
    public MainPanel() {
        panel =new JPanel();//构造函数添加属性
        this.layout();//调用布局
    }
    private void layout() {//布局
        jlInput = new JLabel("请输入猜的数字：");
        jlMessage = new JLabel("消息提示：");
        jtfInput = new JTextField();
        jbOk =new JButton("猜");
        jbRestart =new JButton("开始一个新游戏");
        panel.setLayout(new GridLayout(4,1));//4行1列，panel是容器
        panel.add(jbRestart);
        JPanel inputPanel =new JPanel();
        inputPanel.setLayout(new GridLayout(1,2));
        inputPanel.add(jlInput);
        inputPanel.add(jtfInput);//实现容器叠加jlInput，jtfInput放在一行
        
        panel.add(inputPanel);
        panel.add(jbOk);
        //panel.add(jlInput);
        panel.add(jlMessage);//注意add按照顺序添加0
        //panel.add(jtfInput);
    }
    public JPanel getPanel() {
        return panel;
    }
    

}

。。。。。。。
package c07;

import javax.swing.JFrame;//创建简单

public class MainFrame {
    private JFrame window;//window框架,组件放panel
    public MainFrame() {
        window=new JFrame();//构造
        window.setSize(400,200);//窗口大小
        window.add(new MainPanel().getPanel());
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口
        window.setTitle("My First Wiondow Application");//命名标题
        //window.setAlwaysOnTop(true);
        window.setVisible(true);
        
    }
    public static void main(String[] args) {
        new MainFrame();
    }

}

、、、、、、、、、、、、、、、、、、、、、、完整 猜数字简单图形界面、、、、、、、、、、

package c07;

import javax.swing.JFrame;

public class MainFrame {
    private JFrame window;//window框架,组件放panel
    public MainFrame() {
        window=new JFrame();//构造
        window.setSize(400,200);//窗口大小
        window.add(new MainPanel().getPanel());
        //window.add(new PicturePanel());
        window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//关闭窗口
        window.setTitle("My First Wiondow Application");//命名标题
        //window.setAlwaysOnTop(true);
        window.setVisible(true);
    }
    public static void main(String[] args) {
        new GuessNumber();
        new MainFrame();
    }
}

package c07;

import java.awt.GridLayout;
import java.awt.Panel;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;//效果include import

public class MainPanel {
    private JPanel panel;
    private JLabel jlInput,jlMessage;
    private JTextField jtfInput;
    private JButton jbOk,jbRestart;//创建组件之后布局
    private GuessNumber engine;
    public MainPanel() {
        panel =new JPanel();//构造函数添加属性
        engine = new GuessNumber();
        engine.generateRand();
        this.layout();//调用布局
        jbOk.addActionListener(new OKListener());
    }
    class OKListener implements ActionListener{

        @Override
        public void actionPerformed(ActionEvent arg0) {
            // TODO Auto-generated method stub
            int num = Integer.parseInt(jtfInput.getText());
            engine.setGuessNumber(num);
            engine.compare(jlMessage);
            //System.out.println(jtfInput.getText());
            //jlMessage.setText("num = "+num);
        }//创建监听器
    }
    private void layout() {//布局
        jlInput = new JLabel("请输入猜的数字：");
        jlMessage = new JLabel("消息提示：");
        jtfInput = new JTextField();
        jbOk =new JButton("猜");
        jbRestart =new JButton("开始一个新游戏");
        panel.setLayout(new GridLayout(4,1));//4行1列，panel是容器
        panel.add(jbRestart);
        JPanel inputPanel =new JPanel();
        inputPanel.setLayout(new GridLayout(1,2));
        inputPanel.add(jlInput);
        inputPanel.add(jtfInput);//实现容器叠加jlInput，jtfInput放在一行
        
        panel.add(inputPanel);
        panel.add(jbOk);
        //panel.add(jlInput);
        panel.add(jlMessage);//注意add按照顺序添加0
        //panel.add(jtfInput);
    }
    public JPanel getPanel() {
        return panel;
    }
    

}

package c07;

import java.util.Scanner;

import javax.swing.JLabel;

public class GuessNumber {
    private int randNumber,guessNumber;
    public int getRandNumber() {
        return randNumber;
    }
    
    public void setGuessNumber(int guessNumber) {
        this.guessNumber = guessNumber;
    }
    public void generateRand() {
        randNumber=(int)(Math.random()*101);
    }
    /*void readGuessNumber() {
        Scanner s=new Scanner(System.in);
        System.out.print("Please input your guess number:");
        guessNumber =s.nextInt();
                //s.close();
    }*/
    boolean compare(JLabel jlMessage){
        //比较正确返回true错误返回false并提示是大还是小。
        boolean result = false;
        if(guessNumber==randNumber)
            jlMessage.setText("right");
        else if(guessNumber>randNumber) 
            jlMessage.setText(" 大了");
        else if(guessNumber<randNumber)
            jlMessage.setText("小了");
        return result;
        
    }
    /*void play()
    {
        generateRand();//系统生成一个随机数
        do {
            readGuessNumber();
        }
        while(!compare());
        //输入一个数
        //比较：如果对了，结束；如果错了，继续输入
        System.out.println("-----------end--------------");
    }*/
/*public static void main(String[] args)
{
    GuessNumber game=new GuessNumber();
    game.play();
}*/
}

2018-4-8
||逻辑或运算 前面条件正确不看后面
|布尔或 前面正确仍查询后面运算正确与否

static不加在局部变量，在全局变量没有static为成员变量 有static类变量

static int i=2；//初始化块

2018-4-10
练习1：
public class AccountBook {
    private String accountName;
    private double income;
    private double outcome;
    public AccountBook(String accountName) {
        this.accountName = accountName;
    }
    public String getAccountName() {
        return accountName;
    }
    public void setAccountName(String accountName) {
        this.accountName = accountName;
    }
    public double getIncome() {
        return income;
    }
    public void setIncome(double income) {
        if(income>=0)
        this.income = income;
    }
    public double getOutcome() {
        return outcome;
    }
    public void setOutcome(double outcome) {
        if(outcome >=0)
        this.outcome = outcome;
    }
    public double compute()
    {
        return income -outcome;
    }
    public static void main(String args[])
    {
        AccountBook a = new AccountBook("张三");
        a.setIncome(30);
        a.setOutcome(10);
        System.out.println(a.getAccountName());
        System.out.println(a.getIncome());
        System.out.println(a.getOutcome());
    }
}

练习2：1. 定义一个汽车类Car，要求如下：
1) 属性包括：汽车品牌brand（String类型）、颜色color（String类型）和速度speed（double类型），并且所有属性为私有。
2) 至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但速度的初始值必须为0）。
3) 为私有属性提供访问器方法。注意：汽车品牌一旦初始化之后不能修改。
定义测试类CarTest，在其main方法中创建一个品牌为“benz”、颜色为“black”的汽车。

public class Car {
    private String brand;
    private String color;
    private double speed;
    public Car(String brand,String color) {
        this.brand =brand;
        this.color =color;
        speed=0;
    }
    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public double getSpeed() {
        return speed;
    }
    public void setSpeed(double speed) {
        this.speed = speed;
    }
    
}

//测试类
public class CarTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Car car = new Car("benz","black");
        System.out.println(car.getBrand());
        System.out.println(car.getColor());
        System.out.println(car.getSpeed());
        car.setBrand("uuu");
        car.setColor("yyy");
        car.setSpeed(99.9);
        System.out.println(car.getBrand());
        System.out.println(car.getColor());
        System.out.println(car.getSpeed());
    }

}

ArrayList线性表
异常
文件IO
多线程

//////////////////////输出字符串s1 s2 s3，并删除s1 再次输出剩余/////////////////////////////
package a;

import java.util.ArrayList;
import java.util.Iterator;

public class A {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ArrayList<String> list = new ArrayList<String>();
        String s1 = "001", s2 = "002", s3 = "003";
        list.add(s1);
        list.add(s2);
        list.add(s3);
        for (String i : list)
            System.out.println(i);
        if (list.contains(s1))
            list.remove(s1);
        for (Iterator<String> it = list.iterator(); it.hasNext();)
            System.out.println(it.next());
    }
}

///////////////
练习3
题目：设计一个描述二维平面上点的类Point，要求如下：
（a）该类需要描述点的浮点型的横坐标x和纵坐标y。
（b）提供能够初始化横纵坐标的有参构造方法，要求参数名称与属性同名。
（c）计算两点间距离的方法distance。
提示：两点之间距离等于两点横纵坐标之差的平方和再开方
Math类中求平方根的方法：static double sqrt(double  a)

public class Point {
    private double x;
    private double y;
    public Point(double x, double y) {
        super();
        this.x = x;
        this.y = y;
    }  
    public double distance(Point p2)
    {
        return Math.sqrt((this.x-p2.x)*(this.x-p2.x)+(this.y-p2.y)*(this.y-p2.y));
    }//Math.pow(this.x-p2.x,2)+Math.pow(this.y-p2.y,2)平方和
    public double getX() {
        return x;
    }
    public void setX(double x) {
        this.x = x;
    }
    public double getY() {
        return y;
    }
    public void setY(double y) {
        this.y = y;
    }
}

//测试类
public class PointTest {

    public static void main(String[] args) {
        Point p1= new Point(2,3);
        Point p2= new Point(4,5);
        System.out.println("两点间距离："+p1.distance(p2));
    }

}

2018-4-12
练习4

题目：定义类，属性包括商品名称name（String）、商品编号id(String)和价格price（double）三个属性，
有无参的构造方法和计算折扣价格并输出的方法，方法头为public void computeDiscout(double percent)，
其中形参代表打折的百分比。
创建商品类的对象，调用计算折扣价格的方法。

package day412;
public class Account {
    private String name;
    private String id;
    private double price;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        this.price = price;
    }
    public Account(String name, String id, double price) {
        super();
        this.name = name;
        this.id = id;
        this.price = price;
    }
    public void computeDiscout(double percent)
    {
         System.out.println("商品打折后价格：" +price*percent);
    }
}
 

//测试
package day412;

public class AccountTest {
     public static void main(String[] args){
            Account a = new Account("虾条","07",25);
            System.out.println("商品名称"+a.getName());
            System.out.println("商品编号"+a.getId());
            System.out.println("商品价格"+a.getPrice());
           a.computeDiscout(0.9);

          }

}

//////////////////////////
get 和set 方法 是在你需要调用或者取出类里面定义的属性的值的时候要用到的，
没有get方法 你就不能从外面取到这个类里面属性的值，
没有set方法，你就不能从外面来往这个类里面的属性注入值
/////////////////////////

///至少提供一个有参的构造方法（要求品牌和颜色可以初始化为任意值，但存储容量的初始值必须为0）
public MP3(String brand,String color){
        this.brand=brand;
        this.color=color;
        capacity=0;///初始值为0在构造中不定义即可
        
    }

///////////定义好类型如mp3，电风扇品牌则不输入不用set函数只是读取用get
////////////初始化不能更改 只有get 没有set函数

///不带参数的构造
void show(){
System.out.println("书名是"+name);
System.out.println("作者是"+author);
System.out.println("价格是"+price);
}  

/////构造里面有个价格特殊要求
public Fan(String model,double price){
        this.model=model;
        if(price >=0)
            this.price=price;
        this.running=false;
        
    }

/////无参构造函数
public class Prog1 {
    private int pingshi,qimo;

    public Prog1() {
        pingshi=60;
        qimo=45;
    }
    public void calculateScore()
    {
        System.out.println(pingshi+qimo*0.5);
    }
}
//测试
public class Prg1Test {
     public static void main(String[] args){
          Prog1 s = new Prog1();
          s.calculateScore();
}
}
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
在类中有方法中用return 对应测试类中System。。。。
等效      方法中System     对应测试类中直接调用对象。方法名（）
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5

覆盖的目的：子类对父类拓展了，父类原有的方法在子类里面也需要升级。

super.getinfo();

super:是在子类对象中对父类对象的引用。
this是与成员变量名称相同实际是子类自己

////////方法覆盖
//父类
public class Goods {
    double unitPrice;//单价
    double account;//数量
     Goods(double unitPrice, double account){
            this.unitPrice=unitPrice ;
            this.account=account ;
    }
    double totalPrice() {//计算总价格
            return unitPrice * account;
    }
    void show() {
            System.out.println("单价是" + unitPrice);
            System.out.println("购买数量为" + account);
            System.out.println("购买商品的总金额是" + this.totalPrice());
    }
}

//子类
public class Milk extends Goods {
    private double vipPrice;
    public Milk(double p,double a,double vipPrice) 
    {
        super(p,a);
        this.vipPrice = vipPrice;
    }
    void show()
    {
        super.show();//调用父类方法
        System.out.println(vipPrice);
    }
}

/////////////

//Scanner s = new Scanner(System.in);
//new Scanner(System.in)创建一个Scanner，控制台会一直等待输入，直到敲回车键结束，把所输入的内容传给Scanner，作为扫描对象。
//int x = s.nextInt();
//要获取输入的内容，则只需要调用Scanner的nextLine()方法
public class TestScanner { 
        public static void main(String[] args) { //定义main方法
                Scanner s = new Scanner(System.in); //定义scanner，等待输入
                System.out.println("请输入字符串："); 
                while (true) { 
                        String line = s.nextLine(); //读取输入内容
                        if (line.equals("exit")) break; //如果读取到exit，则退出输入
                        System.out.println(">>>" + line); //打印输入内容
                } 
        } 
}

2018-4-13
HashMap 数据结构 （在搜索的同时提高添加删除的效率，）《key，value》键值对

package a;

import java.util.*;
import java.util.Map.Entry;
public class Main {

    public static void main(String[] args) {
        HashMap<String, String> map = new HashMap<String,String>();
        map.put("zhangming","Java");
        map.put("zhaoying", "JSP");
        map.put("liuheng","JSP");
        map.put("wangwei","Oracle");
        map.put("guanxin","JDBC");
        map.replace("wangwei", "Oracle", "JSP");
        Set<String> st = map.keySet();    
        for (String i : st) {
            System.out.println(map.get(i));
        }
        System.out.println("-----------------------");
        for (Entry<String, String> i : map.entrySet()) {
            if(i.getValue() == "JSP")
                System.out.println(i.getKey());
        }
     }

}

I/O流，
网络，
异常处理，
多线程：同一时刻执行多个任务

单线程：thread，多条线集合为网络
2018-4.18
1线程的本质：
   1.以前编写的程序，任意时刻只有一条语句在执行
   2.有了多条线程，—————可同时有多条语句在执行
   3.每个线程为一个对象

2线程的创建：
线程类实现Runnable接口
扩展实现Runnable接口的类

多线程创建动画

工厂气压安全控制

3.线程同步：
当某个资源被多个线程同时访问，可能会放生意想不到的事情
解决办法：——锁机制
4.synchronized函数--调用时该对象被锁定，该对象的所有synchronized函数无法被调用，直到第一个函数执行完毕并解除锁定

5.类锁，每个类也有一个锁，synchronized static函数，避免static数据被同时访问

6.控制线程状态的常用方法
     1.yield（）
只希望让其他正在等待的线程有机会执行，且在没有其他线程等待的情况下，立即重新执行
     2.join（）
如果一个线程需要等待；另一个线程的消亡后继续执行，则可以调用希望其消亡的那个线程的join（）方法

7.异常处理

通过返回值判断异常处理return0正常-1，-2.。。。
通过返回值判断异常弊端：函数使用者无手册使用时判断异常的原因
Java里异常处理机制优点
方便类库的使用者
极大改善程序的可读性

希望不论异常是否出现，是否被捕获，都执行某些代码，则可将这段代码放入finally子句中

return
P330-5，331-7
风车动态

文件IO，网络编程，服务器客户端，测试