weixin_44529105的博客

1.网络编程1.1 网络编程介绍小结：网络编程中有两个主要的问题如何准确定位到网络上的一台或者多台主机找到主机之后如何进行通信网络编程中的要素ip和端口号----通过ip类网络通信协议----通过udp和tcp类万物皆对象1.2 IPip地址：InetAddress1. 唯一定位一台网络上的计算机2. 127.0.0.1 : 本机localhost3. IP地址的分类 ipv4/ipv6 ipv4：127.0.0.1，4个字节组成，0-255 ipv6：1

贪吃蛇游戏note1.定义数据2.画到面板上3.监听事件：键盘，事件游戏启动类package snake;import javax.swing.*;//游戏的启动类public class StartDemo extends JFrame { public static void main(String[] args) { StartDemo startDemo = new StartDemo(); startDemo.setBounds(1.

1.简介Gui的核心技术： Swing，AWT为什么用的不多：1.因为界面不美观2.需要jre环境为什么要学习：1.可以写一些自己想要的小工具2.工作的时候可能要维护Swing界面（概率极小）3.可以通过这个了解MVC架构和监听2.AWT2.1Awt介绍1.包含了很多类和接口！GUI2.元素：窗口，按钮，文本框3.java.awt2.2组件和容器1. framepackage lesson01;import java.awt.*;//GUI的第一个界面publi

自定义一个异常类package com.guo.operator.exception;//自定义的异常类public class Demo04 extends Exception{ //继承Exception类 private int detail; //传递数字》10则抛出异常 public Demo04(int detail) { this.detail = detail; } //tostring：异常的打印信息 ..

利用try监控，catch来捕获异常，假设要捕获多个异常，顺序必须从小到大package com.guo.operator.exception;public class Demo01 { public static void main(String[] args) { int a = 1; int b = 0; //假设要捕获多个异常：顺序得从小到大 try {//try监控区域 System.ou.

=========================================首先定义TimeService和UserService两个接口package com.guo.operator.oo.Demo05;public interface TimeService { void time();}package com.guo.operator.oo.Demo05;//interface 定义的关键字 就是接口public interface UserService {.

定义一个抽象类Action抽象方法只有名字，没有方法体，交给子类去完成package com.guo.operator.oo.Demo04;//abstract 抽象类：类 extends：单继承 （接口可以多继承）public abstract class Action { //约束 可以让子类来进行方法的实现 //abstract，抽象方法，只有方法名字，没有方法的实现！ public abstract void doSomething();

静态属性，非静态属性，静态方法，非静态方法的使用注意package com.guo.operator.oo.Demo03;//staticpublic class Student { public double score;//非静态的属性 public static int age;//静态的属性 多线程 public void run(){ Student s1 = new Student(); System.out.println(

首先分别创建父类Person，子类Student和Teacherpackage com.guo.operator.oo.Demo02;public class Person { public void run(){ System.out.println("run"); }}package com.guo.operator.oo.Demo02;public class Student extends Person{ public void go(){

多态注意事项：1. 多态是方法的多态，属性没有多态2. 多态只存在与继承中，即父类和子类，或者有联系的（Object），如果没有就会出现类型转换异常！ClassCastError3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象 即Father f1 = new Son();有些方法不能被重写： 1. static方法，它是属于类的，不属于实例，类刚创立就存在了 2. final常量，无法修改 3， private方法，私有的也不能被重写=========.

重写：需要有继承关系，子类重写父类的方法 1.方法名必须相同 2.参数列表必须相同 3.修饰符：范围可以扩大但不能缩小重写：子类的方法和父类必须要一致，但是方法体（里面的内容）不同为什么需要重写： 1.父类的功能，子类不一定需要，或者不一定满足 alt+insert ：override=====================================================创建个父类B，子类A，静态创建方法say()，用Main()来输出他

super注意点： 1.super调用父类的构造方法，必须在子类构造方法的第一个 2.super必须只能出现在子类的方法或者构造方法中 3.super和this不能同时调用构造方法和this的区别： 代表的对象不同： this：本身调用者这个对象 super：代表父类对象的引用 前提： this：没有继承也可以使用 super：只能在继承条件下才可以使用 构造方法： this(

创建一个父类Personpackage oop.Demo02;//在java中，所有的类，都默认直接或间接继承Object//父类public class Person { //public //protected //default //private //private修饰的属性，子类无法调用 private int money = 10_0000_0000; public void say(){ System.out.

创建Student这个封装类package oop.Demo01;//封装public class Student { //属性私有 //一般封装都是对属性而言，在属性前加private private String name; private int id; private char sex; private int age; //提供一些可以操作这个属性的方法 //提供一些public的get、set方法 //get

创建student这个类，静态和非静态分别创建say（）方法package com.guo.operator.oop;//学生类public class Student { public static void main(String[] args) { } //非静态方法， public void say(){ System.out.println("..."); } //静态方法// public static void s

方法的定义package com.guo.operator.oop;//回顾方法定义//Demo01类public class Demo01 { //main方法 public static void main(String[] args) { } /* 修饰符 返回值类型 方法名（。。。）{ //方法体 return 返回值； } */ //return 结束方法，返回一个结果 p

1.类与对象类是一个模板：抽象，对象是一个具体的实例2.方法定义，调用3.对应的引用引用类型：基本类型（8种）byte short char int long float double boolean对象都是通过引用来操作的：栈----》堆4.属性：字段Field 成员变量默认初始化数字：0，0.0char：u0000boolean：false引用：null修饰符 属性类型 属性名 = 属性值5.对象的创建和使用- 必须使用new 关键字创造对象，构造器 Person pers

/* public static void main(String[] args) { Person person = new Person("ggggg"); System.out.println(person.name); } 构造器： 1.和类名相同 2.没有返回值 作用： 1.new本质就是在调用构造器 2.初始化对象的值 注意点： 1.定义有参构造

package com.guo.operator.oo;//学生类public class Student { //属性：字段 String name; int age; //方法 public void study(){ System.out.println(this.name+"在学习"); }}/*//类是抽象的，需要实例化 //类实例化后会返回一个自己的对象 //student对象就是一个

package com.guo.operator.array;import com.sun.java.swing.plaf.windows.WindowsToolBarSeparatorUI;import java.util.Arrays;//稀疏矩阵public class ArrayDemo08 { public static void main(String[] args) { //1.创建一个二维数组11*11 0：没有棋子 1：黑棋 2：白棋

package com.guo.operator.array;import java.util.Arrays;public class ArrayDemo07 { public static void main(String[] args) { int[] a = {1,32,42,3,5,2,65}; int[] b = sort(a); System.out.println(Arrays.toString(b)); } /

package com.guo.operator.array;import java.util.Arrays;//调用Arrays类public class ArrayDemo06 { public static void main(String[] args) { int[] a= {5,6,3,7,1}; //打印数组元素，Array.toString System.out.println(Arrays.toString(a));

package com.guo.operator.array;public class ArrayDemo05 { //二维数组 public static void main(String[] args) { int[][] array = {{1,2},{2,3}}; for (int i = 0; i <array.length ; i++) { } System.out.print(array[0][1])

foreach循环一般是用来打印出数组的案例package com.guo.operator.array;public class ArrayDemo03 { public static void main(String[] args) { int[] array = {1,2,3,4,5}; //For-each循环(一般是用来打印输出一些结果) jdk1.5 没有下标// for (int i : array) {//

1.首先声明数组，此时数组为空，在栈中2.创建数组，此时数组在堆中3.给数组赋值静态和动态创建数组package com.guo.operator.array;public class ArrayDemo02 { public static void main(String[] args) { //静态初始化:创建+赋值 int[] num = {1,2,3}; System.out.println(num[0]); .

package com.guo.operator.method;import java.util.Scanner;public class Demo05 { public static void main(String[] args) { double x; double y; String caozuo; Scanner scanner = new Scanner(System.in); while (true

一般不用递归，避免大量运算时使用递归，容易造成栈满，内存溢出递归阶乘代码实例package com.guo.operator.method;//递归public class Demo04 { //阶乘 public static void main(String[] args) { System.out.println(f(5)); } public static int f(int n ){ if(n==1){

package com.guo.operator.method;import java.util.Scanner;//可变参数//1.一个方法只能有一个可变参数//2。它必须是方法的最后一个参数，任何普通的参数必须在它之前声明public class Demo03 { public static void main(String[] args) { //调用可变参数的方法 printMax(32,1,2,34,5); printMax(n

package com.guo.operator.method;public class Demo02 { public static void main(String[] args) { int t = max(10,10); //double t = max(10.0,20.0); System.out.println(t); } //方法重载，方法名都一样，只换了参数的类型 //方法重载规则：1.方法名称必须相同

package com.guo.operator.method;public class Demo01 { //MAIN方法 public static void main(String[] args) { //实际参数：实际调用传递给函数的参数 int add = add(1,2); //int add = add(1,3,4); System.out.println(add); } //加法 /

package com.guo.operator.struct;public class TestDemo { public static void main(String[] args) { //打印倒三角形 for(int i = 1;i <= 5;i++){ for(int j = 5;j >= i;j--){ System.out.print(" "); }

breakpackage com.guo.operator.struct;//break在任何循环语句的主体部分，均可用break控制循环的流程。//break用于强行退出循环，不执行循环中剩余的语句。public class BreakDemo { public static void main(String[] args) { int i = 0; while (i<100){ System.out.println(i++)

代码1package com.guo.operator.struct;public class SwitchDemo01 { public static void main(String[] args) { //case穿透 //switch匹配一个具体的值 char grade = 'C'; switch (grade){ case 'A': System.out.println("

whilepackage com.guo.operator.struct;public class WhileDemo01 { public static void main(String[] args) { int i = 0; int sum = 0; while (i<=100){ sum = sum + i; i++; } System.out.prin

package com.guo.operator.struct;import java.util.Scanner;public class IfDemo01 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); System.out.println("请输入你的成绩："); int score = scanner.nextInt(

for循环####代码1package com.guo.operator.struct;public class ForDemo01 { public static void main(String[] args) { //练习1：计算0-100奇数和偶数的和 int oddsum = 0; int evensum = 0; for (int i = 0; i < 100; i++) { //可使用快捷键100.f

next()package com.guo.operator.Scanner;import java.util.Scanner;//next()不能带有空格的字符串 输入hello world，只会出现hello；以空格为结束符public class Demo01 { public static void main(String[] args) { //创建一盒扫描器对象，用于接收键盘数据（new Scanner(System.in);+alt+enter）

包package com.guo.operator.operator;import com.guo.operator.*;//导入operator包下所有东西public class Demo09 {}doc文档package com.guo.operator.operator;/** * @author guo * @version 1.0 * @since 1.8 *///加在类上面就是类的注释public class doc { String name;

二元运算符package operator;public class Demo01 { public static void main(String[] args) { //二元运算符 //Ctrl+D：复制当前行到下一行 int a = 10; int b = 20; int c = 30; int d = 40; System.out.println(a+b);//30

变量public class demo04 { //类变量 static static double salary = 2500; //实例变量：从属于对象:如果不自行初始化，这个类型就是默认值0 0.0 //bool默认为false //其余默认值都为null String name; int age; //main方法 public static void main(String[] args) { //局